package com.srs.web.controller.aitutor;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.srs.common.core.controller.BaseController;

// OkHttp 显式导入
import com.srs.common.exception.ServiceException;
import com.srs.common.utils.SecurityUtils;
import com.srs.common.utils.ServletUtils;
import com.srs.framework.web.service.TokenService;
import com.srs.teacher.domain.dto.ConversationDTO;
import com.srs.web.core.config.DifyConfig;
import okhttp3.*;

// Spring 显式导入（不要用 *)
import com.srs.common.core.domain.AjaxResult; // ✅ RuoYi 的返回结果类
import okhttp3.RequestBody;
import okhttp3.ResponseBody;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;

import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;

import java.io.BufferedReader;
import java.io.IOException;

import java.time.Duration;
import java.util.*;
import java.util.concurrent.CompletableFuture;

/**
 * Dify聊天控制器
 * <p>
 * 该控制器用于处理与Dify AI聊天服务的通信，提供流式聊天功能。
 * Dify是一个LLM应用开发平台，此控制器通过调用其API实现与AI模型的交互。
 * </p>
 */
@RestController
@RequestMapping("/aitutor/aichat")
public class AiChatController extends BaseController {
    @Autowired
    private TokenService tokenService;
    /**
     * HTTP客户端实例
     * 配置了5分钟的读取超时时间，用于与Dify API进行通信
     */
    private final OkHttpClient client = new OkHttpClient.Builder()
            .connectTimeout(Duration.ofSeconds(5)) // 建连超时
            .readTimeout(Duration.ofSeconds(12)) // 读超时（服务端应在此内有数据返回）
            .writeTimeout(Duration.ofSeconds(12)) // 写超时
            .retryOnConnectionFailure(true)
            .build();

    /**
     * Redis模板，用于缓存会话ID
     */
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    /**
     * Dify配置类
     * 用于获取Dify的API密钥和其他配置参数
     */
    @Autowired
    private DifyConfig difyConfig;

    /** 为本次请求设置 “总超时”（含连接/读写），避免无限挂起 */
    private Response execWithTimeouts(Request req, int callSecs, int readSecs, int writeSecs) throws IOException {
        OkHttpClient shortClient = client.newBuilder()
                .callTimeout(java.time.Duration.ofSeconds(callSecs)) // 整次调用最大时长
                .readTimeout(java.time.Duration.ofSeconds(readSecs)) // 读超时（这段时间没有字节到达就超时）
                .writeTimeout(java.time.Duration.ofSeconds(writeSecs)) // 写超时
                .build();
        return shortClient.newCall(req).execute();
    }

    /**
     * JSON对象映射器
     * 用于处理JSON数据的序列化和反序列化
     */
    private final ObjectMapper mapper = new ObjectMapper();

    /**
     * 处理流式聊天请求的端点
     * <p>
     * 该方法接收客户端发送的聊天请求，并通过SSE（Server-Sent Events）方式将响应流式传输回客户端。
     * 使用异步处理避免阻塞主线程，提高系统并发处理能力。
     * </p>
     *
     * @param requestData 包含聊天请求数据的Map，应包含以下字段：
     *                    - query: 用户的聊天消息内容（必需）
     *                    - user: 用户标识符（必需）
     *                    - conversation_id: 对话ID，用于维持对话上下文（可选）
     *                    - inputs: 输入参数，用于传递额外的上下文信息（可选）
     * @return SseEmitter 用于向客户端流式传输响应的SSE发射器
     */
    @PostMapping("/stream")
    public SseEmitter stream(@org.springframework.web.bind.annotation.RequestBody Map<String, Object> requestData) {

        SseEmitter emitter = new SseEmitter(300_000L);

        // 设置超时处理回调
        emitter.onTimeout(() -> {
            System.out.println("!!! SSE连接超时 !!!");
            emitter.complete();
        });

        // 设置错误处理回调
        emitter.onError(ex -> {
            System.out.println("!!! SSE连接发生错误 !!!");
            ex.printStackTrace();
            emitter.completeWithError(ex);
        });

        // 在主线程中获取当前用户名，避免在异步线程中获取安全上下文
        String currentUsername = SecurityUtils.getLoginUser().getUsername();
        // 获取JWT token
        String currentUserToken = tokenService.getToken(ServletUtils.getRequest());
//        String currentUserToken = SecurityUtils.getLoginUser().getToken();
        // 异步执行请求处理，避免阻塞主线程
        CompletableFuture.runAsync(() -> {
            try {
                sendToDifyAndStream(requestData, emitter, currentUsername, currentUserToken);
            } catch (Exception e) {
                e.printStackTrace();
                try {
                    emitter.send(SseEmitter.event().name("error").data("服务器内部错误: " + e.getMessage()));
                } catch (IOException ioException) {
                    ioException.printStackTrace();
                }
                emitter.completeWithError(e);
            }
        });
        return emitter;
    }

    /**
     * 发送请求到Dify并流式传输响应
     * <p>
     * 该方法构建请求参数，调用Dify API，并处理返回的流式响应数据。
     * 根据Dify API返回的不同事件类型，将数据通过SSE发送给客户端。
     * </p>
     *
     * @param requestData     包含聊天请求数据的Map，包含用户消息、用户标识等信息
     * @param emitter         用于向客户端发送SSE事件的发射器
     * @param currentUsername
     * @throws IOException 当网络请求或IO操作失败时抛出
     */
    private void sendToDifyAndStream(Map<String, Object> requestData, SseEmitter emitter, String currentUsername,
            String currentUserToken)
            throws IOException {

        // 构建请求体参数
        Map<String, Object> bodyMap = new HashMap<>();
        bodyMap.put("query", requestData.get("query")); // 用户消息内容
        bodyMap.put("user", currentUsername); // 用户标识
        bodyMap.put("response_mode", "streaming"); // 设置为流式响应模式

        // 如果请求中没有提供conversation_id，则尝试获取或创建一个
        if (!requestData.containsKey("conversation_id") || requestData.get("conversation_id") == null) {
            try {
                List<ConversationDTO> conversations = getConversations(currentUsername, null, 1, "-updated_at");
                if (conversations != null && !conversations.isEmpty()) {
                    // 使用已有的会话ID
                    bodyMap.put("conversation_id", conversations.get(0).getId());
                }
                // 如果没有会话，Dify会自动创建一个新的会话
            } catch (Exception e) {
                System.out.println("获取用户会话时出错: " + e.getMessage());
                // 继续执行，让Dify自动创建新会话
            }
        } else {
            // 如果存在对话ID，则添加到请求参数中
            bodyMap.put("conversation_id", requestData.get("conversation_id"));
        }

        // 添加输入参数，默认为空HashMap
        Map<String, Object> inputs = (Map<String, Object>) requestData.getOrDefault("inputs", new HashMap<>());

        inputs.put("user_id", currentUsername);

        Object userName = requestData.get("user_name");
        if (userName != null) {
            inputs.put("user_name", userName);
        }

        // Object userToken = requestData.get("user_token");
        if (currentUserToken != null) {
            inputs.put("user_token", currentUserToken);
        }

        Object userRole = requestData.get("user_role");
        if (userRole != null) {
            inputs.put("user_role", userRole);
        }

        Object userPlatform = requestData.get("user_platform");
        if (userPlatform != null) {
            inputs.put("user_platform", userPlatform);
        }

        bodyMap.put("inputs", inputs);

        // 自动为对话生成名称
        bodyMap.put("auto_generate_name", false);

        // 将请求参数转换为JSON字符串
        String jsonBody = mapper.writeValueAsString(bodyMap);

        // 创建请求体对象
        RequestBody body = RequestBody.create(MediaType.get("application/json; charset=utf-8"), jsonBody);

        // 构建HTTP请求
        Request httpRequest = new Request.Builder()
                .url(difyConfig.getApiUrl()) // 设置请求URL
                .addHeader("Authorization", "Bearer " + difyConfig.getApiKey()) // 添加认证头
                .addHeader("Content-Type", "application/json") // 设置内容类型
                .post(body) // 设置为POST请求
                .build();

        // 执行HTTP请求
        try (Response httpResponse = client.newCall(httpRequest).execute()) {
            // 检查响应是否成功
            if (!httpResponse.isSuccessful()) {
                String errorMsg = "Dify 请求失败: " + httpResponse.code() + " " + httpResponse.message();
                System.out.println(errorMsg);
                try {
                    httpResponse.body().string();
                } catch (Exception e) {
                    System.out.println("无法读取响应体: " + e.getMessage());
                }
                emitter.send(SseEmitter.event().name("error").data(errorMsg));
                emitter.complete();
                return;
            }

            // 读取响应流数据
            try (BufferedReader reader = new BufferedReader(httpResponse.body().charStream())) {
                String line;
                while ((line = reader.readLine()) != null) {
                    if (line.isEmpty() || !line.startsWith("data:"))
                        continue;
                    String jsonData = line.substring(5).trim();
                    if ("[DONE]".equals(jsonData)) {
                        break;
                    }

                    // 解析JSON数据
                    JsonNode node = mapper.readTree(jsonData);
                    String eventType = node.get("event").asText();

                    // 根据事件类型处理不同的响应，直接转发原始数据
                    switch (eventType) {
                        case "workflow_started":
                        case "node_started":
                        case "node_finished":
                        case "message_start":
                        case "message":
                        case "message_end":
                        case "error":
                        case "ping":
                            // 直接转发Dify的原始SSE数据格式
                            emitter.send(SseEmitter.event().data(jsonData));
                            break;
                        default:
                            break;
                    }
                }
            }
            // 完成SSE流传输
            emitter.complete();
        } catch (Exception e) {
            // 处理异常情况
            e.printStackTrace();
            emitter.completeWithError(e);
        }
    }

    /**
     * 提交消息反馈（点赞、点踩、撤销、文本反馈）
     * <p>
     * 该接口代理前端调用 Dify 的反馈 API，避免在前端暴露 API Key。
     * 支持：'like', 'dislike', 或 null（撤销）
     * </p>
     *
     * @param feedbackData 包含 feedback 信息的 JSON 对象
     *                     示例：
     *                     {
     *                     "message_id": "msg-123",
     *                     "user": "user-1",
     *                     "rating": "like", // "like", "dislike", 或 null
     *                     "content": "回答很好"
     *                     }
     * @return 统一响应结果
     */
    @PostMapping("/feedback")
    public AjaxResult submitFeedback(
            @org.springframework.web.bind.annotation.RequestBody Map<String, Object> feedbackData) {
        // 校验必要字段
        String messageId = (String) feedbackData.get("message_id");
        if (messageId == null || messageId.trim().isEmpty()) {
            return AjaxResult.error("message_id 不能为空");
        }

        // 获取 user（必填，建议前端传）
        Object userObj = feedbackData.get("user");
        if (userObj == null || userObj.toString().trim().isEmpty()) {
            return AjaxResult.error("user 不能为空");
        }
        String user = userObj.toString();

        // 处理 rating：支持 "like", "dislike", null（撤销）
        Object ratingObj = feedbackData.get("rating");
        String rating = null;

        if (ratingObj != null) {
            String raw = ratingObj.toString();
            if ("like".equals(raw)) {
                rating = "like";
            } else if ("dislike".equals(raw)) {
                rating = "dislike";
            } else {
                return AjaxResult.error("rating 必须是 'like'、'dislike' 或 null（撤销）");
            }
        }
        // 如果 ratingObj 为 null，rating 保持 null，表示撤销

        // 可选 content
        String content = (String) feedbackData.get("content");

        // 构建请求体（发送给 Dify）
        Map<String, Object> bodyMap = new HashMap<>();
        bodyMap.put("user", user);
        bodyMap.put("rating", rating); // 可以是 "like", "dislike", 或 null
        bodyMap.put("content", content); // 可选文本反馈

        try {
            // 序列化为 JSON
            String jsonBody = mapper.writeValueAsString(bodyMap);
            okhttp3.RequestBody body = okhttp3.RequestBody.create(
                    MediaType.get("application/json; charset=utf-8"),
                    jsonBody);

            // 调用 Dify API
            Request request = new Request.Builder()
                    .url(difyConfig.getFeedbackBaseUrl() + "/" + messageId + "/feedbacks")
                    .addHeader("Authorization", "Bearer " + difyConfig.getApiKey())
                    .addHeader("Content-Type", "application/json")
                    .post(body)
                    .build();

            try (Response response = client.newCall(request).execute()) {
                if (response.isSuccessful()) {
                    return AjaxResult.success("反馈提交成功");
                } else {
                    String errorMsg = "Dify 反馈失败: " + response.code();
                    try (ResponseBody errorBody = response.body()) {
                        if (errorBody != null) {
                            errorMsg += " - " + errorBody.string();
                        }
                    } catch (IOException e) {
                        errorMsg += " (无法读取错误详情)";
                    }
                    return AjaxResult.error(errorMsg);
                }
            }
        } catch (Exception e) {
            return AjaxResult.error("提交反馈失败: " + e.getMessage());
        }
    }

    /**
     * 获取APP的消息点赞和反馈列表
     * <p>
     * 该接口用于获取整个Dify应用的终端用户反馈、点赞列表，类似Dify的日志界面
     * </p>
     *
     * @param page  页码，默认值：1
     * @param limit 每页数量，默认值：20，最大100
     * @return 包含点赞、反馈列表的统一响应结果
     */
    @GetMapping("/app/feedbacks")
    public AjaxResult getAppFeedbacks(
            @RequestParam(value = "page", defaultValue = "1") String page,
            @RequestParam(value = "limit", defaultValue = "20") String limit) {

        try {
            // 参数校验和限制
            int limitValue = Math.min(Math.max(Integer.parseInt(limit), 1), 100);

            // 构建请求
            Request request = new Request.Builder()
                    .url(difyConfig.getApiFeedbackUrl() + page + "&limit=" + limitValue)
                    .addHeader("Authorization", "Bearer " + difyConfig.getApiKey())
                    .addHeader("Content-Type", "application/json")
                    .get()
                    .build();

            // 发送请求
            try (Response response = client.newCall(request).execute()) {
                if (response.isSuccessful()) {
                    String responseBody = response.body().string();
                    JsonNode rootNode = mapper.readTree(responseBody);

                    // 解析数据
                    JsonNode dataNode = rootNode.get("data");
                    List<Map<String, Object>> feedbackList = new ArrayList<>();

                    if (dataNode != null && dataNode.isArray()) {
                        for (JsonNode feedbackNode : dataNode) {
                            Map<String, Object> feedbackItem = new HashMap<>();

                            // 提取反馈信息
                            feedbackItem.put("id", feedbackNode.has("id") ? feedbackNode.get("id").asText() : null);
                            feedbackItem.put("message_id",
                                    feedbackNode.has("message_id") ? feedbackNode.get("message_id").asText() : null);
                            feedbackItem.put("rating",
                                    feedbackNode.has("rating") ? feedbackNode.get("rating").asText() : null);
                            feedbackItem.put("content",
                                    feedbackNode.has("content") ? feedbackNode.get("content").asText() : null);
                            feedbackItem.put("created_at",
                                    feedbackNode.has("created_at") ? feedbackNode.get("created_at").asLong() : null);
                            feedbackItem.put("app_id",
                                    feedbackNode.has("app_id") ? feedbackNode.get("app_id").asText() : null);
                            feedbackItem.put("conversation_id",
                                    feedbackNode.has("conversation_id") ? feedbackNode.get("conversation_id").asText()
                                            : null);

                            feedbackList.add(feedbackItem);
                        }
                    }

                    // 直接返回数组形式的数据
                    return AjaxResult.success(feedbackList);
                } else {
                    String errorMsg = "获取反馈列表失败: " + response.code() + " " + response.message();
                    try (ResponseBody errorBody = response.body()) {
                        if (errorBody != null) {
                            String errorBodyString = errorBody.string();
                            errorMsg += " - 响应体: " + errorBodyString;

                            // 尝试解析响应体中的错误信息
                            try {
                                JsonNode errorNode = mapper.readTree(errorBodyString);
                                if (errorNode.has("message")) {
                                    errorMsg += " - 错误详情: " + errorNode.get("message").asText();
                                }
                            } catch (Exception e) {
                                // 如果无法解析为JSON，就保持原始响应体
                            }
                        }
                    } catch (IOException e) {
                        errorMsg += " (无法读取错误详情): " + e.getMessage();
                    }
                    return AjaxResult.error(errorMsg);
                }
            }
        } catch (Exception e) {
            return AjaxResult.error("获取反馈列表时发生异常: " + e.getMessage());
        }
    }

    // 权限标识为辅导员
    @PreAuthorize("@ss.hasPermi('cph:teacher:list')")
    @GetMapping("/getMessagesToAdmin")
    public AjaxResult getMessagesToAdmin(@RequestParam String user,
            @RequestParam(required = false) String firstId,
            @RequestParam(defaultValue = "20") int limit,
            @RequestParam(defaultValue = "-updated_at") String sortBy) {

        try {
            // 首先尝试从Redis缓存中获取会话ID
            String conversationId = getCachedConversationId(user);

            // 如果Redis缓存中没有会话ID，则使用原来的方法获取
            if (conversationId == null) {
                List<ConversationDTO> conversations = getConversations(user);

                if (conversations == null || conversations.isEmpty()) {
                    return AjaxResult.error("暂无会话记录");
                }

                conversationId = conversations.get(0).getId();

                // 将获取到的会话ID缓存到Redis中
                cacheConversationId(user, conversationId);
            }

            Map<String, Object> result = getConversationHistoryMessages(conversationId, user, firstId, limit);

            AjaxResult successResult = success(result);
            return successResult;
        } catch (IOException e) {
            e.printStackTrace();
            return AjaxResult.error("网络请求失败，请稍后重试getMessagesToAdmin");
        } catch (Exception e) {
            e.printStackTrace();
            return AjaxResult.error("请求处理失败: " + e.getMessage());
        }
    }

    // 权限标识为学生
    @GetMapping("/getMessagesToUser")
    public AjaxResult getMessagesToUser(@RequestParam(required = false) String firstId,
            @RequestParam(defaultValue = "20") int limit,
            @RequestParam(defaultValue = "-updated_at") String sortBy) {

        try {
            String user = SecurityUtils.getLoginUser().getUsername();

            // 首先尝试从Redis缓存中获取会话ID
            String conversationId = getCachedConversationId(user);

            // 如果Redis缓存中没有会话ID，则使用原来的方法获取
            if (conversationId == null) {
                List<ConversationDTO> conversations = getConversations(user);

                if (conversations == null || conversations.isEmpty()) {
                    return AjaxResult.error("暂无会话记录");
                }

                conversationId = conversations.get(0).getId();

                // 将获取到的会话ID缓存到Redis中
                cacheConversationId(user, conversationId);
            }

            Map<String, Object> result = getConversationHistoryMessages(conversationId, user, firstId, limit);

            AjaxResult successResult = success(result);
            return successResult;
        } catch (IOException e) {
            e.printStackTrace();
            return AjaxResult.error("网络请求失败，请稍后重试getMessagesToUser");
        } catch (Exception e) {
            e.printStackTrace();
            return AjaxResult.error("请求处理失败: " + e.getMessage());
        }
    }

    /**
     * 从Redis缓存中获取用户的会话ID
     *
     * @param user 用户名
     * @return 会话ID，如果不存在则返回null
     */
    private String getCachedConversationId(String user) {
        try {
            // 参数校验
            if (user == null || user.trim().isEmpty()) {
                return null;
            }

            user = user.trim();
            String cacheKey = difyConfig.getConversationCachePrefix() + user;

            // 从Redis中获取会话ID
            String conversationId = stringRedisTemplate.opsForValue().get(cacheKey);

            return conversationId;
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 将会话ID与用户绑定并存储到Redis中
     *
     * @param user           用户名
     * @param conversationId 会话ID
     */
    private void cacheConversationId(String user, String conversationId) {
        try {
            // 参数校验
            if (user == null || user.trim().isEmpty()) {
                return;
            }

            if (conversationId == null || conversationId.trim().isEmpty()) {
                return;
            }

            user = user.trim();
            conversationId = conversationId.trim();

            // 将用户与会话ID绑定存储到Redis中
            String cacheKey = difyConfig.getConversationCachePrefix() + user;
            stringRedisTemplate.opsForValue().set(
                    cacheKey,
                    conversationId,
                    Duration.ofHours(difyConfig.getConversationCacheExpireHours()));
        } catch (Exception e) {
            System.out.println("绑定会话ID时发生错误: " + e.getMessage());
        }
    }

    /*
     * 获取会话列表
     */
    public List<ConversationDTO> getConversations(String user, String lastId, int limit, String sortBy)
            throws IOException {
        // 构建带查询参数的 URL
        HttpUrl.Builder urlBuilder = HttpUrl.parse(difyConfig.getConversationsUrl()).newBuilder();
        urlBuilder.addQueryParameter("user", user);
        if (lastId != null && !lastId.trim().isEmpty()) {
            urlBuilder.addQueryParameter("last_id", lastId);
        }
        urlBuilder.addQueryParameter("limit", String.valueOf(limit));
        urlBuilder.addQueryParameter("sort_by", sortBy);

        // 构建请求
        Request request = new Request.Builder()
                .url(urlBuilder.build())
                .addHeader("Authorization", "Bearer " + difyConfig.getApiKey())
                .get()
                .build();

        // 执行请求
        try (Response response = execWithTimeouts(request, 8, 8, 8)) {
            if (!response.isSuccessful()) {
                throw new IOException("Dify API 请求失败: " + response.code() + " " + response.message());
            }

            // 读取响应体
            String responseBodyString = response.body().string();
            JsonNode rootNode = mapper.readTree(responseBodyString);

            // 提取 data 数组
            JsonNode dataArray = rootNode.path("data");
            List<ConversationDTO> conversations = new ArrayList<>();

            if (dataArray.isArray()) {
                for (JsonNode node : dataArray) {
                    ConversationDTO dto = new ConversationDTO();
                    dto.setId(node.path("id").asText(null));
                    dto.setName(node.path("name").asText(null));
                    dto.setIntroduction(node.path("introduction").asText(null));

                    // 处理时间戳（假设接口返回的是 Unix 时间戳，单位：秒）
                    long createdAt = node.path("created_at").asLong(0L);
                    long updatedAt = node.path("updated_at").asLong(0L);

                    dto.setCreated_at(createdAt > 0 ? new Date(createdAt * 1000) : null);
                    dto.setUpdated_at(updatedAt > 0 ? new Date(updatedAt * 1000) : null);

                    conversations.add(dto);
                }
            }

            return conversations;
        }
    }

    public List<ConversationDTO> getConversations(String user) throws IOException {
        return getConversations(user, null, 1, "-updated_at");
    }

    public List<ConversationDTO> getConversations(String user, String lastId) throws IOException {
        return getConversations(user, lastId, 1, "-updated_at");
    }

    public List<ConversationDTO> getConversations(String user, Integer limit, String sortBy) throws IOException {
        return getConversations(user, null, limit, sortBy);
    }

    // 获取历史消息
    private Map<String, Object> getConversationHistoryMessages(
            String conversationId,
            String user,
            String firstId,
            Integer limit) throws ServiceException {

        // 参数校验
        if (conversationId == null || conversationId.trim().isEmpty()) {
            throw new IllegalArgumentException("conversationId 不能为空");
        }
        if (user == null || user.trim().isEmpty()) {
            throw new IllegalArgumentException("user 不能为空");
        }

        conversationId = conversationId.trim();
        user = user.trim();
        int finalLimit = limit != null && limit > 0 ? Math.min(limit, 100) : 20;

        // 构建请求 URL
        HttpUrl.Builder urlBuilder = HttpUrl.parse(difyConfig.getApiHistoryUrl()).newBuilder();
        urlBuilder.addQueryParameter("conversation_id", conversationId);
        urlBuilder.addQueryParameter("user", user);
        if (firstId != null && !firstId.trim().isEmpty()) {
            urlBuilder.addQueryParameter("first_id", firstId.trim());
        }
        urlBuilder.addQueryParameter("limit", String.valueOf(finalLimit));

        Request request = new Request.Builder()
                .url(urlBuilder.build())
                .addHeader("Authorization", "Bearer " + difyConfig.getApiKey())
                .addHeader("Accept", "application/json")
                .get()
                .build();

        try (Response response = execWithTimeouts(request, 8, 8, 8)) {

            if (!response.isSuccessful()) {
                String body = response.body() != null ? response.body().string() : "No body";
                String msg = String.format("HTTP %d %s - %s", response.code(), response.message(), body);
                throw new ServiceException("请求失败");
            }

            ResponseBody responseBody = response.body();
            if (responseBody == null) {
                return emptyResult(finalLimit);
            }

            String responseBodyString = responseBody.string();
            JsonNode rootNode;
            try {
                rootNode = mapper.readTree(responseBodyString);
            } catch (JsonProcessingException e) {
                throw new ServiceException("响应数据格式错误");
            }

            // 提取 data 数组
            List<Map<String, Object>> data = new ArrayList<>();
            JsonNode dataArray = rootNode.get("data");
            if (dataArray != null && dataArray.isArray()) {
                data = mapper.convertValue(dataArray, new TypeReference<List<Map<String, Object>>>() {
                });
            }

            // 提取 has_more
            boolean hasMore = rootNode.path("has_more").asBoolean(false);

            // ✅ 直接构建前端需要的返回结构
            Map<String, Object> result = new HashMap<>();
            result.put("data", data);
            result.put("has_more", hasMore);
            result.put("limit", finalLimit);
            return result; // 直接返回，调用方直接丢给前端

        } catch (IOException e) {
            throw new ServiceException("网络请求失败: " + e.getMessage());
        }
    }

    // 辅助方法：返回空结果
    private Map<String, Object> emptyResult(int limit) {
        Map<String, Object> result = new HashMap<>();
        result.put("data", new ArrayList<>());
        result.put("has_more", false);
        result.put("limit", limit);
        return result;
    }

    /**
     * 文件上传接口
     * <p>
     * 上传文件并在发送消息时使用，可实现图文多模态理解。支持应用程序所支持的所有格式。
     * 上传的文件仅供当前终端用户使用。
     * </p>
     *
     * @param file 要上传的文件
     * @param user 用户标识，用于定义终端用户的身份
     * @return 包含文件信息的统一响应结果
     */
    @PostMapping("/files/upload")
    public AjaxResult uploadFile(@RequestParam("file") MultipartFile file,
            @RequestParam("user") String user) {
        try {
            // 检查文件是否为空
            if (file.isEmpty()) {
                return AjaxResult.error("文件不能为空");
            }

            // 创建MultipartBody以上传文件
            RequestBody requestBody = new MultipartBody.Builder()
                    .setType(MultipartBody.FORM)
                    .addFormDataPart("user", user)
                    .addFormDataPart("file", file.getOriginalFilename(),
                            RequestBody.create(MediaType.parse("application/octet-stream"), file.getBytes()))
                    .build();

            // 构建请求
            Request request = new Request.Builder()
                    .url(difyConfig.getFilesUrl())
                    .addHeader("Authorization", "Bearer " + difyConfig.getApiKey())
                    .post(requestBody)
                    .build();

            // 发送请求
            try (Response response = client.newCall(request).execute()) {
                if (response.isSuccessful()) {
                    String responseBody = response.body().string();
                    JsonNode rootNode = mapper.readTree(responseBody);

                    // 返回成功结果
                    return AjaxResult.success("文件上传成功", mapper.convertValue(rootNode, Map.class));
                } else {
                    String errorMsg = "文件上传失败: " + response.code() + " " + response.message();
                    try (ResponseBody errorBody = response.body()) {
                        if (errorBody != null) {
                            errorMsg += " - " + errorBody.string();
                        }
                    } catch (IOException e) {
                        errorMsg += " (无法读取错误详情)";
                    }
                    return AjaxResult.error(errorMsg);
                }
            }
        } catch (Exception e) {
            return AjaxResult.error("文件上传异常: " + e.getMessage());
        }
    }
}
