package cn.huge.module.ai.service;

import cn.huge.base.common.exception.ServiceException;
import cn.huge.base.common.utils.GuavaCacheUtils;
import cn.huge.base.common.utils.ObjectUtils;
import cn.huge.base.common.utils.ReturnSucUtils;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.apache.http.HttpEntity;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.client.WebClient;
import org.springframework.web.servlet.mvc.method.annotation.StreamingResponseBody;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

@Slf4j
@Service
@Transactional(rollbackFor = Exception.class)
public class AiDifyService {
    
    @Value("${dify.url}")
    private String difyUrl;
    
    @Value("${dify.getMediateStrategyApi}")
    private String getMediateStrategyApi;
    
    @Value("${dify.getMediateCaseDialogApi}")
    private String getChatApi;

    @Value("${dify.getPropertyDialogApi}")
    private String getPropertyDialogApi;
    
    @Value("${dify.user}")
    private String user;
    
    /**
     * 发送 http post 请求，参数以原生字符串进行提交，因为ai请求时间过长，在此另外实现一个请求方法
     * @param url 请求地址
     * @param stringJson json字符串数据
     * @param headers 请求头
     * @param encode 编码
     * @return
     * @throws Exception
     */
    public static String httpPostRaw(String url, String stringJson, Map<String, String> headers, String encode) throws Exception{
        if(encode == null){
            encode = "utf-8";
        }
        CloseableHttpClient closeableHttpClient = HttpClients.createDefault();
        //设置请求和传输超时时间，这里将时间设置为五分钟
        RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(300000).setConnectTimeout(300000).build();
        HttpPost httpost = new HttpPost(url);
        httpost.setConfig(requestConfig);
        //设置header
        httpost.setHeader("Content-type", "application/json");
        if (ObjectUtils.isNotEmpty(headers)) {
            for (Map.Entry<String, String> entry : headers.entrySet()) {
                httpost.setHeader(entry.getKey(),entry.getValue());
            }
        }
        //组织请求参数
        StringEntity stringEntity = new StringEntity(stringJson, encode);
        httpost.setEntity(stringEntity);
        String content = null;
        CloseableHttpResponse httpResponse = null;
        try {
            //响应信息
            httpResponse = closeableHttpClient.execute(httpost);
            HttpEntity entity = httpResponse.getEntity();
            content = EntityUtils.toString(entity, encode);
        } catch (Exception e) {
            e.printStackTrace();
            throw new Exception("网络连接异常，请稍候重试!", e);
        }finally{
            try {
                if (httpResponse != null) {
                    httpResponse.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        try {  //关闭连接、释放资源
            closeableHttpClient.close();
        } catch (IOException e) {
            e.printStackTrace();
            throw new Exception("网络连接异常，请稍候重试!", e);
        }
        return content;
    }
    
    /**
     * 获取案件调解策略
     * 处理流程：
     * 1. 优先从缓存获取调解策略
     * 2. 如无缓存记录，则请求AI服务生成调解策略
     * 3. 将生成的调解策略保存到缓存
     *
     * @param caseText 案件描述文本
     * @return ReturnSucUtils封装的调解策略结果
     */
    public Object getMediateStrategy(String caseText) {
        String cacheKey = "getMediateStrategy" + caseText.hashCode();
        
        try {
            // 先从缓存获取
            Object cacheAi = GuavaCacheUtils.getCacheAi(cacheKey);
            if (ObjectUtils.isNotEmpty(cacheAi)) {
                return ReturnSucUtils.getRepInfo("请求成功", cacheAi);
            }

            // 参数校验
            if (!validateRequest(caseText)) {
                return ReturnSucUtils.getRepInfo("参数错误", null);
            }

            // 请求AI服务并处理结果
            JSONObject responseObj = requestAiMediateStrategy(caseText);
            
            if (responseObj != null) {
                try {
                    // 从响应中正确提取调解策略
                    String mediateStrategy = responseObj.getJSONObject("data")
                                                        .getJSONObject("outputs")
                                                        .getString("text");
                    if (mediateStrategy != null) {
                        // 清理调解策略中的指定字符
                        if (mediateStrategy.contains("输出格式") || 
                            mediateStrategy.contains("```json{") || 
                            mediateStrategy.contains("}```") || 
                            mediateStrategy.contains("\"content\":\"")) {
                            
                            mediateStrategy = mediateStrategy.replace("输出格式", "").replace("```json{", "")
                                            .replace("}```", "")
                                            .replace("\"content\":\"", "");
                        }
                        // 将调解策略保存到缓存
                        GuavaCacheUtils.putCacheAi(cacheKey, mediateStrategy);
                        return ReturnSucUtils.getRepInfo("请求成功", mediateStrategy);
                    }
                } catch (Exception e) {
                    log.error("解析AI调解策略响应失败: {}", e.getMessage(), e);
                    log.error("返回的JSON格式: {}", responseObj);
                }
            }
            
            return ReturnSucUtils.getRepInfo("调解策略生成失败", null);
        } catch (Exception e) {
            log.error("获取案件调解策略失败: {}", e.getMessage(), e);
            return ReturnSucUtils.getRepInfo("调解策略生成异常", null);
        }
    }

    /**
     * 验证请求参数
     */
    private boolean validateRequest(String caseText) {
        if (caseText == null || caseText.trim().isEmpty()) {
            log.warn("输入参数为空，caseText: {}", caseText);
            return false;
        }
        return true;
    }

    /**
     * 请求AI调解策略服务
     * @param caseText 案件描述文本
     * @return AI服务响应结果
     */
    private JSONObject requestAiMediateStrategy(String caseText) {
        try {
            // 构建请求参数
            Map<String, Object> requestBody = new HashMap<>();
            Map<String, Object> inputs = new HashMap<>();
            inputs.put("caseText", caseText);
            requestBody.put("inputs", inputs);
            requestBody.put("response_mode", "blocking");
            requestBody.put("user", user);

            // 设置请求头
            Map<String, String> headers = new HashMap<>();
            headers.put("Authorization", "Bearer " + getMediateStrategyApi);

            // 发送请求到Dify服务
            String response = httpPostRaw(difyUrl + "/workflows/run",
                    JSONObject.toJSONString(requestBody), headers, "utf-8");
            
            return JSONObject.parseObject(response);
        } catch (Exception e) {
            log.error("请求AI调解策略服务失败: {}", e.getMessage(), e);
            return null;
        }
    }

    /**
     * 提供流式对话功能
     * 该方法通过WebClient向Dify服务发送流式对话请求，并以流式方式返回AI的回答
     *
     * @param caseText 案件详情文本
     * @param query 用户的提问
     * @param conversationId 对话ID，第一次对话时为空，多轮对话时需要传入
     * @param responseMode 响应模式，可选值为"streaming"或"blocking"
     * @return StreamingResponseBody 流式响应对象
     */
    public StreamingResponseBody streamChat(String caseText, String query, String conversationId, String responseMode) {
        try {
            // 验证responseMode参数
            if (responseMode == null || responseMode.isEmpty()) {
                responseMode = "streaming"; // 默认使用streaming模式
            } else if (!responseMode.equals("streaming") && !responseMode.equals("blocking")) {
                log.warn("不支持的响应模式: {}, 将使用默认的streaming模式", responseMode);
                responseMode = "streaming";
            }
            
            // 构建请求体
            Map<String, Object> requestBody = new HashMap<>();
            Map<String, Object> inputs = new HashMap<>();
            inputs.put("case_text", caseText);
            requestBody.put("inputs", inputs);
            requestBody.put("query", query);
            requestBody.put("response_mode", responseMode);
            requestBody.put("user", user);
            
            // 如果存在对话ID，则添加到请求中
            if (conversationId != null && !conversationId.isEmpty()) {
                requestBody.put("conversation_id", conversationId);
            }
            
            // 创建WebClient，用于发送HTTP请求
            WebClient client = WebClient.builder()
                    .baseUrl(difyUrl + "/chat-messages")
                    .defaultHeader("Content-Type", "application/json")
                    .defaultHeader("Authorization", "Bearer " + getChatApi)
                    .build();
            
            // 返回一个StreamingResponseBody对象，用于处理流式响应
            return outputStream -> client.post()
                    .contentType(MediaType.APPLICATION_JSON)
                    .body(BodyInserters.fromValue(requestBody))
                    .retrieve()
                    .bodyToFlux(DataBuffer.class)
                    .doOnNext(dataBuffer -> {
                        // 将响应数据缓冲区转换为字节数组并写入输出流
                        byte[] bytes = new byte[dataBuffer.readableByteCount()];
                        dataBuffer.read(bytes);
                        try {
                            outputStream.write(bytes);
                            // 刷新输出流以确保数据立即发送
                            outputStream.flush();
                        } catch (IOException e) {
                            log.error("流式写入数据失败: {}", e.getMessage(), e);
                        }
                    })
                    .doOnError(e -> {
                        log.error("流式对话请求失败: {}", e.getMessage(), e);
                    })
                    .blockLast();
        } catch (Exception e) {
            log.error("AI流式对话服务异常: {}", e.getMessage(), e);
            throw new ServiceException("AiDifyService.streamChat", e);
        }
    }

    /**
     * 提供阻塞式对话功能，直接返回完整回答
     * 该方法通过HTTP请求向Dify服务发送阻塞式对话请求，并返回完整的AI回答
     *
     * @param caseText 案件详情文本
     * @param query 用户的提问
     * @param conversationId 对话ID，第一次对话时为空，多轮对话时需要传入
     * @return 包含AI回答和对话ID的Map对象
     */
    public Map<String, Object> blockingChat(String caseText, String query, String conversationId) {
        try {
            // 构建请求体
            Map<String, Object> requestBody = new HashMap<>();
            Map<String, Object> inputs = new HashMap<>();
            inputs.put("case_text", caseText);
            requestBody.put("inputs", inputs);
            requestBody.put("query", query);
            requestBody.put("response_mode", "blocking");
            requestBody.put("user", user);
            
            // 如果存在对话ID，则添加到请求中
            if (conversationId != null && !conversationId.isEmpty()) {
                requestBody.put("conversation_id", conversationId);
            }
            
            // 设置请求头
            Map<String, String> headers = new HashMap<>();
            headers.put("Authorization", "Bearer " + getChatApi);
            
            // 发送请求到Dify服务
            String response = httpPostRaw(difyUrl + "/chat-messages",
                    JSONObject.toJSONString(requestBody), headers, "utf-8");
            
            // 解析响应
            JSONObject responseObj = JSONObject.parseObject(response);
            
            // 提取关键信息
            Map<String, Object> result = new HashMap<>();
            
            // 提取对话ID
            if (responseObj.containsKey("conversation_id")) {
                result.put("conversationId", responseObj.getString("conversation_id"));
            }
            
            // 提取回答内容
            if (responseObj.containsKey("answer")) {
                result.put("answer", responseObj.getString("answer"));
            } else if (responseObj.containsKey("data") && responseObj.getJSONObject("data").containsKey("answer")) {
                result.put("answer", responseObj.getJSONObject("data").getString("answer"));
            }
            
            return result;
        } catch (Exception e) {
            log.error("AI阻塞式对话服务异常: {}", e.getMessage(), e);
            throw new ServiceException("AiDifyService.blockingChat", e);
        }
    }

    /**
     * 提供阻塞式财产对话功能，直接返回完整回答
     * 该方法通过HTTP请求向Dify服务发送阻塞式对话请求，并返回完整的AI回答
     *
     * @param caseText 案件详情文本
     * @param query 用户的提问
     * @param conversationId 对话ID，第一次对话时为空，多轮对话时需要传入
     * @param checkRationality 可选参数，开启AI服务内部的请求合理性检查，默认不传
     * @return 包含AI回答和对话ID的Map对象
     */
    public Map<String, Object> blockingPropertyChat(String query, String conversationId, String checkRationality) {
        try {
            // 构建请求体
            Map<String, Object> requestBody = new HashMap<>();
            Map<String, Object> inputs = new HashMap<>();
            // 如果传入checkRationality且不为空，则添加到请求体
            if (checkRationality != null && !checkRationality.isEmpty()) {
                inputs.put("checkRationality", checkRationality);
            }
            requestBody.put("inputs", inputs);
            requestBody.put("query", query);
            requestBody.put("response_mode", "blocking");
            requestBody.put("user", user);

            // 如果存在对话ID，则添加到请求中
            if (conversationId != null && !conversationId.isEmpty()) {
                requestBody.put("conversation_id", conversationId);
            }

            // 设置请求头
            Map<String, String> headers = new HashMap<>();
            headers.put("Authorization", "Bearer " + getPropertyDialogApi);

            // 发送请求到Dify服务
            String response = httpPostRaw(difyUrl + "/chat-messages",
                    JSONObject.toJSONString(requestBody), headers, "utf-8");

            // 解析响应
            JSONObject responseObj = JSONObject.parseObject(response);

            // 提取关键信息
            Map<String, Object> result = new HashMap<>();

            // 提取对话ID
            if (responseObj.containsKey("conversation_id")) {
                result.put("conversationId", responseObj.getString("conversation_id"));
            }

            // 提取回答内容
            if (responseObj.containsKey("answer")) {
                result.put("answer", responseObj.getString("answer"));
            } else if (responseObj.containsKey("data") && responseObj.getJSONObject("data").containsKey("answer")) {
                result.put("answer", responseObj.getJSONObject("data").getString("answer"));
            }

            return result;
        } catch (Exception e) {
            log.error("AI阻塞式财产对话服务异常: {}", e.getMessage(), e);
            throw new ServiceException("AiDifyService.blockingPropertyChat", e);
        }
    }
}