public class TokenBudget {
    // 总预算
    private final int totalBudget = 8000;
    
    // 固定开支
    private final int systemPromptBudget = 1500;  // System Prompt
    private final int toolDefBudget = 2000;        // 工具定义（约8-10个工具）
    
    // 弹性开支
    private final int historyBudget = 2500;        // 对话历史
    private final int ragBudget = 1000;            // RAG 检索结果
    
    // 预留
    private final int outputBudget = 1000;         // 模型输出
}

@Component
public class DynamicToolLoader {

    /**
     * 根据对话阶段加载不同的工具集
     * 例：用户在问产品问题 → 只加载知识库检索工具
     *     用户要下单 → 加载订单创建工具
     *     用户要查物流 → 加载物流查询工具
     */
    public List<ToolDefinition> loadToolsForContext(String userIntent, 
                                                     ConversationContext context) {
        List<ToolDefinition> tools = new ArrayList<>();
        
        // 基础工具（始终加载）
        tools.add(knowledgeSearchTool);  // RAG 知识库检索
        
        // 意图相关的工具
        switch (classifyIntent(userIntent)) {
            case ORDER_QUERY:
                tools.add(orderQueryTool);
                tools.add(logisticsQueryTool);
                break;
            case ORDER_CREATE:
                tools.add(orderCreateTool);
                tools.add(inventoryCheckTool);
                tools.add(paymentTool);
                break;
            case COMPLAINT:
                tools.add(complaintCreateTool);
                tools.add(escalationTool);
                break;
            case GENERAL_QA:
                // 只加载知识库工具，不加载业务工具
                break;
        }
        
        return tools;
    }
}

// 不好的做法：冗长的描述
@Tool("""
    这个工具用于查询用户的订单信息。你需要提供用户的用户ID和订单ID，
    系统会返回订单的详细信息，包括订单状态、商品列表、收货地址等。
    如果订单不存在，会返回错误信息。
""")
public OrderInfo queryOrder(String userId, String orderId) { ... }

// 好的做法：精简但完整的描述
@Tool("查询订单详情。入参：userId, orderId。返回：状态、商品、地址")
public OrderInfo queryOrder(String userId, String orderId) { ... }

/**
 * 滑动窗口记忆策略
 * 核心思想：最近的对话最重要，越远的越不重要
 * 类比：你和朋友聊天，昨天聊了什么还记得，上周聊了什么就模糊了
 */
public class SlidingWindowChatMemory implements ChatMemory {

    private final int maxMessages;
    private final Deque<Message> window = new LinkedList<>();

    public SlidingWindowChatMemory(int maxMessages) {
        this.maxMessages = maxMessages;
    }

    @Override
    public void add(String memoryId, List<Message> messages) {
        window.addAll(messages);
        // 窗口满了，移除最旧的消息
        while (window.size() > maxMessages) {
            window.pollFirst();
        }
    }

    @Override
    public List<Message> get(String memoryId) {
        return new ArrayList<>(window);
    }
}

/**
 * 摘要压缩记忆策略
 * 核心思想：旧对话压缩成摘要，新对话保持原文
 * 类比：你看完一本书，过段时间只记得主要情节，但最近读的章节还记得细节
 */
public class SummaryCompressionMemory implements ChatMemory {

    private final ChatLanguageModel summarizer;
    private final int retainRecentMessages;
    private String compressedSummary = "";
    private final List<Message> recentMessages = new ArrayList<>();

    public SummaryCompressionMemory(ChatLanguageModel summarizer, 
                                      int retainRecentMessages) {
        this.summarizer = summarizer;
        this.retainRecentMessages = retainRecentMessages;
    }

    @Override
    public void add(String memoryId, List<Message> messages) {
        recentMessages.addAll(messages);
        
        if (recentMessages.size() > retainRecentMessages * 2) {
            // 需要压缩
            compressOldMessages();
        }
    }

    private void compressOldMessages() {
        // 取出需要压缩的旧消息
        List<Message> toCompress = recentMessages.subList(
            0, recentMessages.size() - retainRecentMessages
        );
        
        // 让 LLM 生成摘要
        String summaryPrompt = String.format(
            "请将以下对话历史压缩为一段简洁的摘要，保留关键信息（用户身份、" +
            "重要决策、未完成的任务）。不超过200字。\n\n对话历史：\n%s",
            formatMessages(toCompress)
        );
        
        String newSummary = summarizer.generate(summaryPrompt);
        
        // 与旧摘要合并
        if (!compressedSummary.isEmpty()) {
            compressedSummary = "【之前的对话摘要】" + compressedSummary + 
                              "\n【最新对话摘要】" + newSummary;
        } else {
            compressedSummary = newSummary;
        }
        
        // 只保留最近的消息
        recentMessages.clear();
        recentMessages.addAll(
            toCompress.subList(
                Math.max(0, toCompress.size() - retainRecentMessages), 
                toCompress.size()
            )
        );
    }

    @Override
    public List<Message> get(String memoryId) {
        List<Message> result = new ArrayList<>();
        if (!compressedSummary.isEmpty()) {
            result.add(SystemMessage.from("【历史对话摘要】" + compressedSummary));
        }
        result.addAll(recentMessages);
        return result;
    }
}

/**
 * Token 感知的滑动窗口
 * 核心思想：按 Token 预算裁剪，而不是按消息数量
 * 好处：不管用户发长文还是短文，都能精确控制上下文大小
 */
public class TokenAwareWindowMemory implements ChatMemory {

    private final ChatLanguageModel model;
    private final int maxInputTokens;
    private final List<Message> messages = new ArrayList<>();
    private final TokenEstimator tokenEstimator;

    public TokenAwareWindowMemory(ChatLanguageModel model, int maxInputTokens) {
        this.model = model;
        this.maxInputTokens = maxInputTokens;
        this.tokenEstimator = new TokenEstimator();
    }

    @Override
    public void add(String memoryId, List<Message> newMessages) {
        messages.addAll(newMessages);
        
        // 从最新的消息开始，向前计算 Token
        int totalTokens = 0;
        int cutoffIndex = messages.size();
        
        for (int i = messages.size() - 1; i >= 0; i--) {
            int msgTokens = tokenEstimator.estimate(messages.get(i));
            if (totalTokens + msgTokens > maxInputTokens) {
                cutoffIndex = i + 1;
                break;
            }
            totalTokens += msgTokens;
        }
        
        // 移除超出预算的旧消息
        if (cutoffIndex > 0 && cutoffIndex < messages.size()) {
            List<Message> overflow = new ArrayList<>(
                messages.subList(0, cutoffIndex)
            );
            messages.subList(0, cutoffIndex).clear();
            
            // 把溢出的消息压缩成摘要
            if (!overflow.isEmpty()) {
                String summary = compressToSummary(overflow);
                messages.add(0, SystemMessage.from(
                    "【对话历史摘要】" + summary
                ));
            }
        }
    }

    @Override
    public List<Message> get(String memoryId) {
        return Collections.unmodifiableList(messages);
    }
}

// LangChain4j 源码分析（简化版）
public class TokenWindowChatMemory extends AbstractChatMemory {

    private final int maxTokens;
    private final TokenEstimator tokenEstimator;
    private final ChatMemoryListener listener;  // 溢出消息的处理

    @Override
    protected void doAdd(String memoryId, List<Message> messages) {
        List<Message> currentMessages = chatMemoryStore.getMessages(memoryId);
        currentMessages.addAll(messages);
        
        // 按 Token 裁剪
        ensureCapacity(memoryId, currentMessages);
        
        chatMemoryStore.updateMessages(memoryId, currentMessages);
    }

    private void ensureCapacity(String memoryId, List<Message> messages) {
        int currentTokens = countTokens(messages);
        
        while (currentTokens > maxTokens && messages.size() > 1) {
            // 找到第二条消息（保留 System Message）
            Message removed = messages.remove(1);
            currentTokens -= tokenEstimator.estimate(removed);
            
            // 通过 listener 处理被移除的消息
            if (listener != null) {
                listener.onEvicted(removed);
            }
        }
    }
}

@Configuration
public class AgentContextConfig {

    @Bean
    public ChatClient chatClient(ChatClient.Builder builder) {
        return builder
            // 1. 系统提示 Advisor（固定上下文）
            .defaultSystem("你是一个专业的客服Agent，擅长回答产品问题和处理订单。" +
                          "回答要简洁专业，不确定的信息要明确告知用户。")
            // 2. 上下文压缩 Advisor（弹性上下文）
            .defaultAdvisors(
                new TokenBudgetAdvisor(8000),         // Token 预算控制
                new ContextCompressionAdvisor(),       // 上下文压缩
                new RelevancyFilterAdvisor()           // 相关性过滤
            )
            .build();
    }
}

/**
 * Token 预算控制 Advisor
 * 职责：在发送给 LLM 之前，检查并裁剪上下文到预算范围内
 */
public class TokenBudgetAdvisor implements CallAroundAdvisor {

    private final int maxTokens;
    private final TokenEstimator tokenEstimator = new TokenEstimator();

    public TokenBudgetAdvisor(int maxTokens) {
        this.maxTokens = maxTokens;
    }

    @Override
    public AdvisedResponse aroundCall(AdvisedRequest request, CallAroundAdvisorChain chain) {
        // 1. 计算当前请求的 Token 数
        int currentTokens = estimateRequestTokens(request);
        
        if (currentTokens <= maxTokens) {
            // 在预算内，直接放行
            return chain.nextAroundCall(request);
        }
        
        // 2. 超出预算，需要裁剪
        AdvisedRequest trimmedRequest = trimToFitBudget(request, currentTokens);
        
        return chain.nextAroundCall(trimmedRequest);
    }

    private AdvisedRequest trimToFitBudget(AdvisedRequest request, int currentTokens) {
        // 裁剪策略：优先保留 System Prompt 和当前用户输入
        // 中间的对话历史和 RAG 结果可以被裁剪
        
        List<Message> history = request.adviseContext().get("chat_memory");
        if (history == null || history.isEmpty()) {
            return request;
        }
        
        int overBudget = currentTokens - maxTokens;
        int removedTokens = 0;
        List<Message> trimmedHistory = new ArrayList<>(history);
        
        // 从最旧的消息开始移除
        while (removedTokens < overBudget && trimmedHistory.size() > 1) {
            Message removed = trimmedHistory.remove(0);
            removedTokens += tokenEstimator.estimate(removed);
        }
        
        // 更新请求上下文
        Map<String, Object> newContext = new HashMap<>(request.adviseContext());
        newContext.put("chat_memory", trimmedHistory);
        
        return AdvisedRequest.from(request)
            .advisors(request.advisors())
            .adviseContext(newContext)
            .build();
    }

    @Override
    public String getName() {
        return "TokenBudgetAdvisor";
    }

    @Override
    public int getOrder() {
        return Ordered.HIGHEST_PRECEDENCE;  // 最高优先级，最先执行
    }
}

/**
 * 上下文压缩 Advisor
 * 职责：当对话历史过长时，自动压缩旧消息为摘要
 */
public class ContextCompressionAdvisor implements CallAroundAdvisor {

    private final ChatLanguageModel summarizer;
    private final int compressionThreshold;  // 超过多少条消息触发压缩
    
    public ContextCompressionAdvisor(ChatLanguageModel summarizer, 
                                       int compressionThreshold) {
        this.summarizer = summarizer;
        this.compressionThreshold = compressionThreshold;
    }

    @Override
    public AdvisedResponse aroundCall(AdvisedRequest request, 
                                       CallAroundAdvisorChain chain) {
        List<Message> history = request.adviseContext().get("chat_memory");
        
        if (history == null || history.size() <= compressionThreshold) {
            return chain.nextAroundCall(request);
        }
        
        // 需要压缩
        int retainCount = compressionThreshold / 2;
        List<Message> toCompress = history.subList(0, history.size() - retainCount);
        List<Message> toRetain = history.subList(
            history.size() - retainCount, history.size()
        );
        
        // 生成摘要
        String summary = generateSummary(toCompress);
        
        // 构建新的消息列表
        List<Message> compressedHistory = new ArrayList<>();
        compressedHistory.add(new SystemMessage("【历史摘要】" + summary));
        compressedHistory.addAll(toRetain);
        
        Map<String, Object> newContext = new HashMap<>(request.adviseContext());
        newContext.put("chat_memory", compressedHistory);
        
        return chain.nextAroundCall(
            AdvisedRequest.from(request)
                .adviseContext(newContext)
                .build()
        );
    }

    private String generateSummary(List<Message> messages) {
        String prompt = "将以下对话压缩为摘要，保留：用户身份、关键决策、" +
                       "未完成任务、重要偏好。不超过150字。\n\n" +
                       formatMessages(messages);
        return summarizer.generate(prompt);
    }

    @Override
    public String getName() { return "ContextCompressionAdvisor"; }

    @Override
    public int getOrder() { return Ordered.HIGHEST_PRECEDENCE + 1; }
}

/**
 * 语义缓存实现
 * 核心思路：用户问题 → Embedding → 与缓存中的问题做相似度比对
 *         如果相似度超过阈值 → 直接返回缓存答案
 *         如果不相似 → 调用 LLM → 把问答对存入缓存
 */
@Component
public class SemanticCache {

    private final EmbeddingModel embeddingModel;
    private final VectorStore vectorStore;
    private final double similarityThreshold;

    public SemanticCache(EmbeddingModel embeddingModel, 
                         VectorStore vectorStore,
                         @Value("${cache.similarity-threshold:0.92}") double threshold) {
        this.embeddingModel = embeddingModel;
        this.vectorStore = vectorStore;
        this.similarityThreshold = threshold;
    }

    /**
     * 查找缓存的回复
     */
    public Optional<CachedResponse> findCachedResponse(String userQuery) {
        // 1. 生成查询的 Embedding
        List<Double> queryEmbedding = embeddingModel.embed(userQuery).content();
        
        // 2. 在向量库中搜索相似的问题
        SearchRequest request = SearchRequest.builder()
            .query(userQuery)
            .topK(3)
            .similarityThreshold(similarityThreshold)
            .build();
        
        List<SearchResult> results = vectorStore.similaritySearch(request);
        
        if (!results.isEmpty()) {
            SearchResult bestMatch = results.get(0);
            return Optional.of(new CachedResponse(
                bestMatch.text(),
                bestMatch.metadata().get("answer"),
                bestMatch.score()
            ));
        }
        
        return Optional.empty();
    }

    /**
     * 缓存问答对
     */
    public void cacheResponse(String question, String answer, String agentId) {
        Document doc = Document.builder()
            .text(question)
            .metadata(Map.of(
                "answer", answer,
                "agentId", agentId,
                "timestamp", Instant.now().toString(),
                "hitCount", "0"
            ))
            .build();
        
        vectorStore.add(List.of(doc));
    }
}

@Component
public class CacheInvalidationStrategy {

    /**
     * 基于时间的失效
     */
    public boolean shouldExpire(CachedResponse cached) {
        Duration age = Duration.between(cached.cachedAt(), Instant.now());
        
        // 不同类型的问题，缓存有效期不同
        return switch (cached.category()) {
            case "product_info" -> age.toDays() > 30;    // 产品信息：30天
            case "policy" -> age.toDays() > 7;            // 政策类：7天
            case "order_status" -> true;                   // 订单状态：不缓存
            default -> age.toDays() > 14;                  // 默认：14天
        };
    }

    /**
     * 基于反馈的失效
     * 如果用户对缓存的回答点了"不满意"，标记缓存失效
     */
    public void onNegativeFeedback(String cacheId) {
        // 降低缓存的置信度
        // 连续3次负反馈 → 删除缓存
    }
}

@Component
public class CacheWarmer {

    @EventListener(ApplicationReadyEvent.class)
    public void warmUpCache() {
        // 从知识库加载 FAQ
        List<FAQ> faqs = faqRepository.findAll();
        
        for (FAQ faq : faqs) {
            semanticCache.cacheResponse(
                faq.question(), 
                faq.answer(), 
                "system-warmup"
            );
        }
        
        log.info("缓存预热完成，加载 {} 条 FAQ", faqs.size());
    }
}

@Component
public class PriorityBasedContextTrimmer {

    private final TokenEstimator tokenEstimator = new TokenEstimator();

    /**
     * 按优先级裁剪上下文到预算范围内
     * 裁剪顺序：对话历史 → RAG 结果 → 工具定义 → System Prompt（不动）
     */
    public AgentContext trimToBudget(AgentContext context, int tokenBudget) {
        int currentTokens = estimateTotal(context);
        
        if (currentTokens <= tokenBudget) {
            return context;  // 在预算内
        }
        
        int overBudget = currentTokens - tokenBudget;
        int saved = 0;
        
        // 第一步：裁剪对话历史（保留最近 N 轮）
        if (saved < overBudget) {
            int historySaved = trimHistory(context, overBudget - saved);
            saved += historySaved;
        }
        
        // 第二步：降低 RAG 结果质量（保留高相关性，丢弃低相关性）
        if (saved < overBudget) {
            int ragSaved = trimRagResults(context, overBudget - saved);
            saved += ragSaved;
        }
        
        // 第三步：卸载不必要的工具
        if (saved < overBudget) {
            int toolSaved = trimToolDefinitions(context, overBudget - saved);
            saved += toolSaved;
        }
        
        return context;
    }

    private int trimHistory(AgentContext context, int targetSaving) {
        List<Message> history = context.getChatHistory();
        int saved = 0;
        
        // 从最旧的消息开始移除
        while (saved < targetSaving && history.size() > 2) {
            Message removed = history.remove(0);
            saved += tokenEstimator.estimate(removed);
        }
        
        return saved;
    }

    private int trimRagResults(AgentContext context, int targetSaving) {
        List<Document> ragResults = context.getRagDocuments();
        int saved = 0;
        
        // 按相关性排序，移除低相关性的结果
        ragResults.sort(Comparator.comparingDouble(Document::score).reversed());
        
        while (saved < targetSaving && ragResults.size() > 1) {
            Document removed = ragResults.remove(ragResults.size() - 1);
            saved += tokenEstimator.estimate(removed.text());
        }
        
        return saved;
    }

    private int trimToolDefinitions(AgentContext context, int targetSaving) {
        List<ToolDefinition> tools = context.getToolDefinitions();
        int saved = 0;
        
        // 移除当前对话中不太可能用到的工具
        // 可以用意图分类来判断哪些工具不需要
        List<ToolDefinition> essentialTools = filterEssentialTools(tools, context);
        
        for (ToolDefinition tool : tools) {
            if (!essentialTools.contains(tool)) {
                saved += tokenEstimator.estimate(tool.description());
            }
        }
        
        context.setToolDefinitions(essentialTools);
        return saved;
    }
}

@Configuration
public class MemoryProviderConfig {

    @Bean
    public ChatMemoryProvider chatMemoryProvider() {
        return memoryId -> TokenWindowChatMemory.builder()
            .maxTokens(4000)
            .tokenEstimator(TikTokenTokenEstimator.openAiCl100k())
            .chatMemoryStore(new RedisChatMemoryStore(redisTemplate))
            .addCustomMessageWindow(new SmartMessageWindow())
            .build();
    }
}

/**
 * 智能消息窗口：根据消息重要性决定保留哪些消息
 */
public class SmartMessageWindow implements MessageWindow {

    @Override
    public List<Message> selectMessages(List<Message> allMessages, int tokenBudget) {
        List<ScoredMessage> scored = allMessages.stream()
            .map(m -> new ScoredMessage(m, scoreMessage(m)))
            .sorted(Comparator.comparingDouble(ScoredMessage::score).reversed())
            .collect(Collectors.toList());
        
        List<Message> selected = new ArrayList<>();
        int usedTokens = 0;
        
        for (ScoredMessage sm : scored) {
            int tokens = estimateTokens(sm.message());
            if (usedTokens + tokens <= tokenBudget) {
                selected.add(sm.message());
                usedTokens += tokens;
            }
        }
        
        // 恢复原始顺序
        selected.sort(Comparator.comparingInt(allMessages::indexOf));
        return selected;
    }

    private double scoreMessage(Message message) {
        double score = 0.5;  // 基础分
        
        // 最近的消息加分
        // ...
        
        // 包含关键信息的消息加分（用户名、决策、偏好）
        String content = message.text();
        if (content.contains("我叫") || content.contains("我是")) score += 0.3;
        if (content.contains("想要") || content.contains("决定")) score += 0.2;
        
        // System Message 最高优先级
        if (message instanceof SystemMessage) score += 1.0;
        
        return score;
    }
}

/**
 * 多级记忆管理器
 * L1: 工作记忆（当前对话的最近几轮，Token 感知）
 * L2: 短期记忆（本次会话的摘要，自动压缩）
 * L3: 长期记忆（跨会话的用户画像、偏好，持久化存储）
 */
@Component
public class MultiLevelMemoryManager {

    private final ChatMemory l1Memory;       // 工作记忆
    private final SummaryStore l2Memory;     // 短期记忆
    private final UserProfileStore l3Memory; // 长期记忆
    private final TokenBudget budget;

    public List<Message> buildContext(String userId, String sessionId, 
                                       String currentQuery) {
        List<Message> context = new ArrayList<>();
        
        // L3: 长期记忆（用户画像，优先级最高）
        UserProfile profile = l3Memory.getProfile(userId);
        if (profile != null) {
            context.add(SystemMessage.from(
                "【用户画像】" + profile.toBriefString()
            ));
        }
        
        // L2: 短期记忆（会话摘要）
        String sessionSummary = l2Memory.getSummary(sessionId);
        if (sessionSummary != null) {
            context.add(SystemMessage.from(
                "【本次会话摘要】" + sessionSummary
            ));
        }
        
        // L1: 工作记忆（最近对话）
        List<Message> recentMessages = l1Memory.get(sessionId);
        context.addAll(recentMessages);
        
        // 当前用户输入
        context.add(new UserMessage(currentQuery));
        
        // 检查总 Token 是否超预算
        return budget.trim(context);
    }

    /**
     * 对话结束后，更新各级记忆
     */
    public void afterTurn(String userId, String sessionId, 
                          List<Message> turnMessages) {
        // L1: 更新工作记忆
        l1Memory.add(sessionId, turnMessages);
        
        // L2: 异步压缩为摘要
        if (l1Memory.get(sessionId).size() > 10) {
            asyncCompress(sessionId);
        }
        
        // L3: 提取用户偏好（每 5 轮做一次）
        extractUserPreferences(userId, turnMessages);
    }
}

/**
 * 准确的 Token 估算
 * 不要偷懒用字符数除以某个系数，中文和英文的 Token 密度差异很大
 */
public class TokenEstimator {

    // 使用 tiktoken 库做精确计算
    private final Encoding encoding;

    public TokenEstimator() {
        this.encoding = EncodingFactory.getEncoding("cl100k_base");
    }

    public int estimate(String text) {
        return encoding.encode(text).size();
    }

    public int estimate(Message message) {
        // 角色标记也消耗 Token
        int roleTokens = 4;  // <|start|>assistant<|message|>
        return roleTokens + estimate(message.text());
    }
}

@Component
public class ContextMetrics {

    private final MeterRegistry registry;

    public void recordContextBuild(String agentId, ContextBuildMetrics metrics) {
        // 上下文大小分布
        registry.gauge("agent.context.tokens", 
            Tags.of("agent", agentId), 
            metrics.totalTokens());
        
        // 各部分占比
        registry.gauge("agent.context.system_prompt_ratio",
            Tags.of("agent", agentId),
            (double) metrics.systemPromptTokens() / metrics.totalTokens());
        
        // 缓存命中率
        registry.counter("agent.cache.hit",
            Tags.of("agent", agentId, "hit", String.valueOf(metrics.cacheHit())))
            .increment();
        
        // 压缩触发次数
        if (metrics.compressionTriggered()) {
            registry.counter("agent.context.compression",
                Tags.of("agent", agentId)).increment();
        }
    }
}

/**
 * 智能模型路由器
 * 核心思想：不是所有请求都需要最贵的模型
 */
@Component
public class ModelRouter {

    private final ChatLanguageModel premiumModel;   // GPT-4o
    private final ChatLanguageModel standardModel;  // DeepSeek-V3
    private final ChatLanguageModel liteModel;      // GPT-4o-mini

    public ChatLanguageModel route(String query, ConversationContext context) {
        // 简单问题（闲聊、FAQ）→ lite 模型
        if (isSimpleQuery(query)) return liteModel;
        
        // 需要推理的问题（分析、规划）→ premium 模型
        if (requiresReasoning(query, context)) return premiumModel;
        
        // 默认 → standard 模型
        return standardModel;
    }

    private boolean isSimpleQuery(String query) {
        // 短问题 + 高频模式 → 简单问题
        return query.length() < 50 && matchesCommonPattern(query);
    }

    private boolean requiresReasoning(String query, ConversationContext context) {
        // 多步骤问题、需要分析的问题 → 需要推理
        return query.contains("分析") || query.contains("对比") ||
               query.contains("为什么") || context.getToolCallCount() > 3;
    }
}

/**
 * 异步批处理队列
 * 适用场景：摘要压缩、用户画像提取、内容审核
 */
@Component
public class AsyncLLMBatchProcessor {

    private final ChatLanguageModel batchModel;
    private final BlockingQueue<LLMTask> taskQueue = new LinkedBlockingQueue<>(1000);
    
    @Async
    public CompletableFuture<String> submitBatchTask(LLMTask task) {
        taskQueue.offer(task);
        return task.getFuture();
    }
    
    @Scheduled(fixedDelay = 5000)  // 每5秒处理一次
    public void processBatch() {
        List<LLMTask> batch = new ArrayList<>();
        taskQueue.drainTo(batch, 20);  // 每批最多20个任务
        
        if (batch.isEmpty()) return;
        
        // 合并为单个请求（利用 LLM 的多轮能力）
        String combinedPrompt = batch.stream()
            .map(LLMTask::getPrompt)
            .collect(Collectors.joining("\n---\n"));
        
        String combinedResult = batchModel.generate(combinedPrompt);
        
        // 分发结果
        distributeResults(batch, combinedResult);
    }
}