package com.ssyf.third.bmiss.core;

import cn.hutool.core.util.StrUtil;
import cn.hutool.crypto.digest.DigestUtil;
import cn.hutool.http.HttpRequest;
import cn.hutool.http.HttpResponse;
import cn.hutool.http.HttpUtil;
import cn.hutool.http.Method;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.TimeUnit;

/**
 * 请求管理类
 * 提供HTTP请求发送、重试和超时处理功能
 * 完全对齐Python代码的请求参数封装、加密和请求头格式
 * 
 * @author system
 * @since 1.0
 */
@Slf4j
@Component
public class RequestManager {
    
    @Autowired
    private ConfigManager configManager;
    
    @Autowired
    private EncryptionManager encryptionManager;
    
    /** 默认超时时间（毫秒） */
    private static final int DEFAULT_TIMEOUT = 5000;
    
    /** 默认重试次数 */
    private static final int DEFAULT_RETRY_COUNT = 3;
    
    /** 默认重试间隔（毫秒） */
    private static final int DEFAULT_RETRY_INTERVAL = 1000;
    
    /** 请求管理器是否已初始化 */
    private boolean initialized = false;
    
    /** 服务名称，用于标识不同的服务 */
    private String serviceName = "default_service";
    
    /**
     * 设置配置管理器
     * 
     * @param configManager 配置管理器
     */
    public void setConfigManager(ConfigManager configManager) {
        this.configManager = configManager;
    }
    
    /**
     * 设置加密管理器
     * 
     * @param encryptionManager 加密管理器
     */
    public void setEncryptionManager(EncryptionManager encryptionManager) {
        this.encryptionManager = encryptionManager;
    }
    
    /**
     * 设置服务名称
     * 
     * @param serviceName 服务名称
     */
    public void setServiceName(String serviceName) {
        this.serviceName = serviceName;
    }
    
    /**
     * 初始化请求管理器
     */
    @PostConstruct
    public void init() {
        if (encryptionManager != null) {
            encryptionManager.init();
        }
        this.initialized = true;
        //log.debug("RequestManager初始化完成");
    }
    
    /**
     * 封装请求参数（对齐Python代码的参数封装逻辑）
     * 
     * @param businessParams 业务参数
     * @param serviceName 服务名称
     * @return 封装后的请求参数
     */
    public Map<String, Object> encapsulateRequestParams(Map<String, Object> businessParams, String serviceName) {
        if (!initialized) {
            throw new IllegalStateException("RequestManager未初始化");
        }
        
        // 获取公共参数
        Map<String, Object> commonParams = encryptionManager.getCommonParamsWithTimestamp();
        
        // 合并公共参数和业务参数
        Map<String, Object> allParams = new HashMap<>();
        allParams.putAll(commonParams);
        if (businessParams != null) {
            allParams.putAll(businessParams);
        }
        
        // 随机选择加密密钥
        EncryptionManager.SecretKeyInfo secretKeyInfo = encryptionManager.selectRandomSecretKey();
        
        // 将参数转换为JSON字符串
        String paramsJson = JSONUtil.toJsonStr(allParams);
        
        // 加密参数
        String encryptedParams = encryptionManager.aesEncrypt(paramsJson, secretKeyInfo);
        
        // 生成签名
        String signKey = getSignKey(serviceName);
        String signature = encryptionManager.doubleMd5Sign(encryptedParams, signKey);
        
        // 构建最终请求参数
        Map<String, Object> requestParams = new HashMap<>();
        requestParams.put("data", encryptedParams);
        requestParams.put("sign", signature);
        requestParams.put("keyIndex", secretKeyInfo.getIndex());
        requestParams.put("sign_name", secretKeyInfo.getKey());
        
        // 打印请求参数详情
        //log.debug("=== 封装请求参数详情 ===");
        //log.debug("服务名称: {}", serviceName);
        //log.debug("原始参数: {}", JSONUtil.toJsonStr(allParams));
        //log.debug("加密参数: {}", encryptedParams);
        //log.debug("签名: {}", signature);
        //log.debug("密钥索引: {}", secretKeyInfo.getIndex());
        //log.debug("密钥名称: {}", secretKeyInfo.getKey());
        //log.debug("====================");
        
        return requestParams;
    }
    
    /**
     * 获取签名密钥
     * 
     * @param serviceName 服务名称
     * @return 签名密钥
     */
    private String getSignKey(String serviceName) {
        if (configManager != null && configManager.getEncryption() != null) {
            return configManager.getEncryption().getSignatureKey();
        }
        return "default_sign_key";
    }
    
    /**
     * 发送GET请求
     * 
     * @param url 请求URL
     * @param params 请求参数
     * @return 响应结果
     */
    public String get(String url, Map<String, Object> params) {
        return request(url, Method.GET, params, null);
    }
    
    /**
     * 发送POST请求
     * 
     * @param url 请求URL
     * @param params 请求参数
     * @return 响应结果
     */
    public String post(String url, Map<String, Object> params) {
        return request(url, Method.POST, params, null);
    }
    
    /**
     * 发送POST请求（JSON格式）
     * 
     * @param url 请求URL
     * @param jsonBody JSON请求体
     * @return 响应结果
     */
    public String postJson(String url, String jsonBody) {
        return request(url, Method.POST, null, jsonBody);
    }
    
    /**
     * 统一的请求方法
     * 默认使用加密方式发送请求
     * 
     * @param url 请求URL
     * @param method 请求方法
     * @param params 请求参数
     * @param body 请求体
     * @return 响应结果
     */
    public String request(String url, Method method, Map<String, Object> params, String body) {
        if (StrUtil.isBlank(url)) {
            throw new IllegalArgumentException("请求URL不能为空");
        }
        
        // 检查是否启用加密，默认启用
        boolean useEncryption = configManager.isEncryptionEnabled();
        
        // 记录原始参数
//        //log.debug("=== 原始请求参数 ===");
        log.debug("发起三方请求=URL: {}", url);
        log.debug("方法: {}", method);
        log.debug("原始参数: {}", JSONUtil.toJsonStr(params));
        log.debug("请求体: {}", body);
        log.debug("使用加密: {}", useEncryption);
        //log.debug("==================");
        
        // 如果启用加密，对参数进行加密处理
        Map<String, Object> finalParams = params;
        if (useEncryption && params != null && !params.isEmpty()) {
            finalParams = encryptParams(params);
            
//             记录加密后的参数
            //log.debug("=== 加密后参数 ===");
            //log.debug("加密参数: {}", JSONUtil.toJsonStr(finalParams));
            //log.debug("================");
        }
        
        // 准备请求头 - 优先从参数中获取token，然后从配置获取
        String tokenFromParams = getTokenFromParams(params);
        String signName = getSignNameFromParams(finalParams);
        Map<String, String> headers = prepareHeaders(null, signName, tokenFromParams);

        if(params.containsKey("client_id") && params.get("client_id") != null){
            headers.put("client_id", params.get("client_id").toString());
        }
        
        int retryCount = configManager.getRetryCount();
        int timeout = configManager.getTimeout();

        //sign_data
        Map<String ,Object> map = new HashMap<>();
        map.put("sign_data" ,finalParams.get("sign_data"));
        String jsonDataString = JSONUtil.toJsonStr(map);
        
        for (int attempt = 1; attempt <= retryCount; attempt++) {
            try {
                //log.debug("发送{}请求到{}，第{}次尝试", method, url, attempt);
                
                HttpRequest request = createRequestWithHeaders(url, method, null, jsonDataString, timeout, headers);
                
                // 记录请求头详情
                log.debug("=== 请求头详情 ===");
                Map<String, List<String>> requestHeaders = request.headers();
                for (Map.Entry<String, List<String>> entry : requestHeaders.entrySet()) {
                    log.debug("{}: {}", entry.getKey(), entry.getValue());
                }
                log.debug("================");
                
                HttpResponse response = request.execute();
                
                if (response.isOk()) {
                    String result = response.body();
                    //log.debug("请求成功，响应长度: {} 字节", result.length());
                    
                    // 记录响应详情
                    log.debug("=== 响应详情 ===");
                    log.debug("状态码: {}", response.getStatus());
                    log.debug("响应头: {}", response.headers());
                    log.debug("响应体: {}", result);
                    log.debug("==============");
                    
                    return result;
                } else {
                    log.warn("请求失败，状态码: {}，响应: {}", response.getStatus(), response.body());
                    
                    if (attempt < retryCount) {
                        // 等待后重试
                        TimeUnit.MILLISECONDS.sleep(500);
                        continue;
                    }
                    
                    throw new RuntimeException("请求失败，状态码: " + response.getStatus());
                }
                
            } catch (Exception e) {
                log.error("第{}次请求失败: {}", attempt, e.getMessage());
                
                if (attempt >= retryCount) {
                    throw new RuntimeException("请求失败，重试次数已用完", e);
                }
                
                try {
                    TimeUnit.MILLISECONDS.sleep(500);
                } catch (InterruptedException ie) {
                    Thread.currentThread().interrupt();
                    throw new RuntimeException("请求被中断", ie);
                }
            }
        }
        
        throw new RuntimeException("请求失败");
    }

    /**
     * 准备请求头（完全对齐Python代码的请求头格式）
     * 
     * @param customHeaders 自定义请求头
     * @param signName 签名名称（密钥名称）
     * @return 完整的请求头Map
     */
    public Map<String, String> prepareHeaders(Map<String, String> customHeaders, String signName) {
        return prepareHeaders(customHeaders, signName, null);
    }
    
    /**
     * 准备请求头（完全对齐Python代码的请求头格式）
     * 
     * @param customHeaders 自定义请求头
     * @param signName 签名名称（密钥名称）
     * @param tokenFromParams 从参数中获取的token（优先使用）
     * @return 完整的请求头Map
     */
    public Map<String, String> prepareHeaders(Map<String, String> customHeaders, String signName, String tokenFromParams) {
        Map<String, String> headers = new HashMap<>();
        
        // 添加基础请求头（与Python代码保持一致）
        headers.put("Content-Type", "application/json; charset=utf-8");
        headers.put("User-Agent", "RobotEvents-ThirdParty/1.0.0 (" + serviceName + ")");
        
        // 添加公共参数到请求头（与Python代码保持一致）
        Map<String, String> commonParams = generateCommonParamsForHeaders(signName, tokenFromParams);
        headers.putAll(commonParams);
        
        // 添加自定义请求头
        if (customHeaders != null) {
            headers.putAll(customHeaders);
        }
        
        // 打印请求头详情
        logHeadersDetails(headers);
        
        return headers;
    }
    
    /**
     * 生成用于请求头的公共参数（对齐Python代码的公共参数格式）
     * 
     * @param signName 签名名称
     * @param tokenFromParams 从参数中获取的token（优先使用）
     * @return 公共参数Map
     */
    private Map<String, String> generateCommonParamsForHeaders(String signName, String tokenFromParams) {
        Map<String, String> params = new HashMap<>();
        
        // 基础公共参数（与Python代码保持一致）
        params.put("device", "wap");
        params.put("source", "com.sanya.xinxiulive.lite"); // 与Python代码保持一致
        params.put("request_number", generateRequestNumber());
        params.put("timestamp", String.valueOf(System.currentTimeMillis() / 1000));
        params.put("appversion", "1.0.0");
        
        // 优先使用从参数中获取的token，如果没有则从配置获取
        String token = StrUtil.isNotBlank(tokenFromParams) ? tokenFromParams : getToken();
        params.put("token", token);
        
        // 生成签名（双重MD5，与Python代码保持一致）
        String signature = generateSignature(params, signName);
        params.put("signature", signature);
        
        // 添加签名名称
        if (signName != null) {
            params.put("sign_name", signName);
        }
        
        return params;
    }
    
    /**
     * 生成请求编号（与Python代码保持一致）
     * 
     * @return 请求编号字符串
     */
    private String generateRequestNumber() {
        return "java" + ThreadLocalRandom.current().nextInt(10000, 99999);
    }
    
    /**
     * 获取token（从配置或环境变量获取）
     * 
     * @return token字符串
     */
    private String getToken() {
        // 这里可以从配置管理器或环境变量获取token
        if(configManager.getBusiness() != null && StrUtil.isNotBlank(configManager.getBusiness().getToken())){
            return configManager.getBusiness().getToken();
        }
        return "";
    }
    
    /**
     * 从请求参数中获取token（优先使用）
     * 
     * @param params 请求参数
     * @return token字符串，如果没有则返回null
     */
    private String getTokenFromParams(Map<String, Object> params) {
        if (params != null) {
            // 尝试从多个可能的字段名中获取token
            String[] tokenFieldNames = {"token", "access_token", "auth_token", "authorization"};
            for (String fieldName : tokenFieldNames) {
                if (params.containsKey(fieldName)) {
                    Object tokenValue = params.get(fieldName);
                    if (tokenValue != null && StrUtil.isNotBlank(tokenValue.toString())) {
                        //log.debug("从参数中获取到token: {} (字段: {})", tokenValue, fieldName);
                        return tokenValue.toString();
                    }
                }
            }
        }
        //log.debug("未从参数中获取到token，将使用配置中的token");
        return null;
    }
    
    /**
     * 从加密参数中获取签名名称
     * 
     * @param encryptedParams 加密后的参数
     * @return 签名名称
     */
    private String getSignNameFromParams(Map<String, Object> encryptedParams) {
        if (encryptedParams != null && encryptedParams.containsKey("sign_name")) {
            Object signNameValue = encryptedParams.get("sign_name");
            if (signNameValue != null && StrUtil.isNotBlank(signNameValue.toString())) {
                return signNameValue.toString();
            }
        }
        return null;
    }
    
    /**
     * 生成双重MD5签名（与Python代码保持一致）
     * 
     * @param params 参数Map
     * @param signName 签名名称
     * @return 签名字符串
     */
    private String generateSignature(Map<String, String> params, String signName) {
        try {
            // 按参数名排序并拼接字符串
            List<String> sortedKeys = new ArrayList<>(params.keySet());
            Collections.sort(sortedKeys);
            
            StringBuilder sb = new StringBuilder();
            for (String key : sortedKeys) {
                if (!"signature".equals(key)) { // 排除签名本身
                    sb.append(key).append("=").append(params.get(key)).append("&");
                }
            }
            
            // 移除最后一个&符号
            if (sb.length() > 0) {
                sb.setLength(sb.length() - 1);
            }
            
            String signString = sb.toString();
            
            // 双重MD5加密，与Python代码保持一致
            String firstMd5 = DigestUtil.md5Hex(signString);
            String secondMd5 = DigestUtil.md5Hex(firstMd5);
            
            return secondMd5;
        } catch (Exception e) {
            log.error("生成签名失败: {}", e.getMessage(), e);
            return "";
        }
    }
    
    /**
     * 发送请求（封装参数和请求头）
     * 
     * @param url 请求URL
     * @param businessParams 业务参数
     * @param customHeaders 自定义请求头
     * @param method 请求方法
     * @param serviceName 服务名称
     * @param signName 签名名称（密钥名称）
     * @return 响应结果
     */
    public String sendEncapsulatedRequest(String url, Map<String, Object> businessParams, 
                                         Map<String, String> customHeaders, String method, String serviceName, String signName) {
        if (!initialized) {
            throw new IllegalStateException("RequestManager未初始化");
        }
        
        // 封装请求参数
        Map<String, Object> requestParams = encapsulateRequestParams(businessParams, serviceName);
        
        // 准备请求头（传递signName参数）
        Map<String, String> headers = prepareHeaders(customHeaders, signName);
        
        // 发送请求
        return sendRequest(url, requestParams, headers, method);
    }
    
    /**
     * 发送请求
     * 
     * @param url 请求URL
     * @param params 请求参数
     * @param headers 请求头
     * @param method 请求方法
     * @return 响应结果
     */
    public String sendRequest(String url, Map<String, Object> params, Map<String, String> headers, String method) {
        if (StrUtil.isBlank(url)) {
            throw new IllegalArgumentException("请求URL不能为空");
        }
        
        // 获取配置的超时和重试参数
        int timeout = configManager.getTimeout();
        int retryCount = configManager.getRetryCount();
        int retryInterval = getRetryInterval();
        
        // 构建请求
        HttpRequest request = buildRequest(url, params, headers, method, timeout);
        
        // 执行请求（带重试）
        return executeWithRetry(request, retryCount, retryInterval);
    }
    
    /**
     * 构建HTTP请求
     * 
     * @param url 请求URL
     * @param params 请求参数
     * @param headers 请求头
     * @param method 请求方法
     * @param timeout 超时时间
     * @return HttpRequest对象
     */
    private HttpRequest buildRequest(String url, Map<String, Object> params, Map<String, String> headers, String method, int timeout) {
        HttpRequest request;
        
        if ("GET".equalsIgnoreCase(method)) {
            request = HttpUtil.createGet(url);
            if (params != null && !params.isEmpty()) {
                request.form(params);
            }
        } else if ("POST".equalsIgnoreCase(method)) {
            request = HttpUtil.createPost(url);
            if (params != null && !params.isEmpty()) {
                request.body(JSONUtil.toJsonStr(params));
            }
        } else {
            throw new IllegalArgumentException("不支持的请求方法: " + method);
        }
        
        // 设置请求头
        if (headers != null) {
            for (Map.Entry<String, String> entry : headers.entrySet()) {
                request.header(entry.getKey(), entry.getValue());
            }
        }
        
        // 设置超时
        request.timeout(timeout);
        
        // 记录请求构建详情
        logRequestExecutionDetails(url, method, timeout, configManager.getRetryCount());
        
        return request;
    }
    
    /**
     * 带重试的执行请求
     * 
     * @param request 请求对象
     * @param retryCount 重试次数
     * @param retryInterval 重试间隔
     * @return 响应结果
     */
    private String executeWithRetry(HttpRequest request, int retryCount, int retryInterval) {
        Exception lastException = null;
        
        for (int attempt = 1; attempt <= retryCount; attempt++) {
            try {
                //log.debug("发送请求，第{}次尝试", attempt);
                HttpResponse response = request.execute();
                
                if (response.isOk()) {
                    String responseBody = response.body();
                    //log.debug("请求成功，响应长度: {} 字节", responseBody.length());
                    
                    // 记录响应详情
                    logResponseDetails(response, responseBody);
                    
                    return responseBody;
                } else {
                    log.warn("请求失败，状态码: {}", response.getStatus());
                    lastException = new RuntimeException("HTTP状态码: " + response.getStatus());
                    
                    // 记录失败的响应详情
                    logResponseDetails(response, response.body());
                }
            } catch (Exception e) {
                log.warn("第{}次请求失败: {}", attempt, e.getMessage());
                lastException = e;
            }
            
            // 如果不是最后一次尝试，则等待重试
            if (attempt < retryCount) {
                try {
                    //log.debug("等待{}ms后重试", retryInterval);
                    Thread.sleep(retryInterval);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    throw new RuntimeException("请求被中断", e);
                }
            }
        }
        
        log.error("所有{}次请求尝试均失败", retryCount);
        throw new RuntimeException("请求失败", lastException);
    }
    
    /**
     * 创建HTTP请求对象（带自定义请求头）
     * 
     * @param url 请求URL
     * @param method 请求方法
     * @param params 请求参数
     * @param body 请求体
     * @param timeout 超时时间
     * @param headers 自定义请求头
     * @return HTTP请求对象
     */
    private HttpRequest createRequestWithHeaders(String url, Method method, Map<String, Object> params, String body, int timeout, Map<String, String> headers) {
        HttpRequest request = new HttpRequest(url);
        request.method(method);
        request.timeout(timeout);
        
        // 设置请求头（优先使用自定义请求头）
        if (headers != null && !headers.isEmpty()) {
            for (Map.Entry<String, String> entry : headers.entrySet()) {
                request.header(entry.getKey(), entry.getValue());
            }
        } else {
            // 如果没有自定义请求头，设置基础请求头
            request.header("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36");
            request.header("Accept", "application/json");
            request.header("Content-Type", "application/json; charset=utf-8");
        }
        
        // 处理参数
        if (params != null && !params.isEmpty()) {
            if (Method.GET.equals(method)) {
                // GET请求将参数拼接到URL
                StringBuilder urlBuilder = new StringBuilder(url);
                if (!url.contains("?")) {
                    urlBuilder.append("?");
                } else {
                    urlBuilder.append("&");
                }
                
                for (Map.Entry<String, Object> entry : params.entrySet()) {
                    urlBuilder.append(entry.getKey()).append("=").append(entry.getValue()).append("&");
                }
                
                String finalUrl = urlBuilder.substring(0, urlBuilder.length() - 1);
                request.setUrl(finalUrl);
            }
            else {
                // POST请求设置表单参数
                request.form(params);
            }
        }
        
        // 处理请求体
        if (StrUtil.isNotBlank(body)) {
            request.body(body);
        }
        
        return request;
    }
    
    /**
     * 创建HTTP请求对象
     * 
     * @param url 请求URL
     * @param method 请求方法
     * @param params 请求参数
     * @param body 请求体
     * @param timeout 超时时间
     * @return HTTP请求对象
     */
    private HttpRequest createRequest(String url, Method method, Map<String, Object> params, String body, int timeout) {
        return createRequestWithHeaders(url, method, params, body, timeout, null);
    }
    
    /**
     * 发送加密请求
     * 强制使用加密方式发送请求
     * 
     * @param url 请求URL
     * @param method 请求方法
     * @param params 请求参数
     * @param signName 签名名称（密钥名称）
     * @return 响应结果
     */
    public String encryptedRequest(String url, Method method, Map<String, Object> params, String signName) {
        // 强制启用加密，对参数进行加密处理
        Map<String, Object> encryptedParams = encryptParams(params);
        
        // 准备加密请求头（传递signName参数）
        Map<String, String> headers = prepareHeaders(null, signName);
        
        // 记录强制加密请求
        //log.debug("=== 强制加密请求 ===");
        //log.debug("URL: {}", url);
        //log.debug("方法: {}", method);
        //log.debug("原始参数: {}", JSONUtil.toJsonStr(params));
        //log.debug("加密参数: {}", JSONUtil.toJsonStr(encryptedParams));
        //log.debug("==================");
        
        // 使用自定义请求方法发送请求
        return sendRequest(url, encryptedParams, headers, method.name());
    }
    
    /**
     * 加密请求参数（对齐Python代码的加密格式）
     * 
     * @param params 原始参数
     * @return 加密后的参数
     */
    private Map<String, Object> encryptParams(Map<String, Object> params) {
        if (params == null || params.isEmpty()) {
            return params;
        }
        
        // 检查是否启用请求加密
        if (!configManager.isRequestEncryptionEnabled()) {
            //log.debug("请求加密未启用，使用原始参数");
            return params;
        }
        
        // 将参数转换为JSON字符串
        String jsonParams = JSONUtil.toJsonStr(params);
        
        // 随机选择加密密钥
        EncryptionManager.SecretKeyInfo secretKeyInfo = encryptionManager.selectRandomSecretKey();
        String encryptedData = encryptionManager.aesEncrypt(jsonParams, secretKeyInfo);
        
        // 生成签名（与Python代码保持一致的双重MD5签名）
        String signature = encryptionManager.generateSignature(params);
        
        // 构建加密参数（与Python代码的EncryptionResult格式保持一致）
        Map<String, Object> result = new HashMap<>();
        
        // 构建encrypted_data字段（包含sign_data）
        Map<String, Object> encryptedDataMap = new HashMap<>();
        encryptedDataMap.put("sign_data", encryptedData);
//        result.put("encrypted_data", encryptedDataMap); // 与Python代码保持一致
        
        result.put("sign_name", secretKeyInfo.getName());
        result.put("signature", signature);
        result.put("algorithm", "AES-CBC"); // 添加算法字段
        result.putAll(encryptedDataMap);
        
        // 详细记录加密过程
        //log.debug("=== 参数加密过程 ===");
        //log.debug("原始参数JSON: {}", jsonParams);
        //log.debug("加密后数据: {}", encryptedData);
        //log.debug("使用密钥: {} (索引: {})", secretKeyInfo.getKey(), secretKeyInfo.getIndex());
        //log.debug("签名: {}", signature);
        //log.debug("最终加密参数: {}", JSONUtil.toJsonStr(result));
        //log.debug("==================");
        
        return result;
    }
    
    /**
     * 解析加密响应（对齐Python代码的decrypt_response_data方法）
     * 
     * @param encryptedResponse 加密的响应字符串
     * @return 解密后的JSON对象
     */
    public JSONObject parseEncryptedResponse(String encryptedResponse) {
        if (StrUtil.isBlank(encryptedResponse)) {
            return new JSONObject();
        }
        
        if (!configManager.isResponseDecryptionEnabled()) {
            try {
                return JSONUtil.parseObj(encryptedResponse);
            } catch (Exception e) {
                // 如果解析失败，返回包含原始数据的对象
                JSONObject result = new JSONObject();
                result.put("data", encryptedResponse);
                return result;
            }
        }
        
        try {
            JSONObject responseJson = JSONUtil.parseObj(encryptedResponse);
            
            // 检查是否包含sign_data字段（与Python代码保持一致）
            if (responseJson.containsKey("sign_data")) {
                // 从加密数据中提取签名名称
                String signName = responseJson.getStr("sign_name", configManager.getDefaultSecretKey());
                String encryptedContent = responseJson.getStr("sign_data");
                
                // 解密数据
                String decryptedData = encryptionManager.aesDecrypt(encryptedContent, signName);
                return JSONUtil.parseObj(decryptedData);
            } else {
                // 直接解密数据
                String encryptedData = responseJson.getStr("data");
                if (StrUtil.isNotBlank(encryptedData)) {
                    String decryptedData = encryptionManager.aesDecrypt(encryptedData);
                    return JSONUtil.parseObj(decryptedData);
                }
                
                return responseJson;
            }
                
        } catch (Exception e) {
            log.error("响应数据解密失败: {}", e.getMessage(), e);
            // 与Python代码保持一致，返回包含错误信息的对象
            JSONObject errorResult = new JSONObject();
            errorResult.put("error", "解密失败: " + e.getMessage());
            return errorResult;
        }
    }
    
    /**
     * 获取重试间隔
     * 
     * @return 重试间隔（毫秒）
     */
    private int getRetryInterval() {
        if (configManager != null) {
            return configManager.getRetryInterval();
        }
        return DEFAULT_RETRY_INTERVAL;
    }
    
    /**
     * 记录请求参数详情（对齐Python代码的日志记录）
     * 
     * @param originalParams 原始参数
     * @param encryptedParams 加密后的参数
     * @param signature 签名
     * @param keyIndex 密钥索引
     * @param serviceName 服务名称
     */
    private void logRequestDetails(Map<String, Object> originalParams, String encryptedParams, 
                                  String signature, int keyIndex, String serviceName) {
        //log.debug("=== 请求参数详情 ===");
        //log.debug("服务名称: {}", serviceName);
        //log.debug("原始参数: {}", JSONUtil.toJsonStr(originalParams));
        //log.debug("加密参数: {}", encryptedParams);
        //log.debug("签名: {}", signature);
        //log.debug("密钥索引: {}", keyIndex);
        //log.debug("==================");
    }
    
    /**
     * 记录请求头详情
     * 
     * @param headers 请求头
     */
    private void logHeadersDetails(Map<String, String> headers) {
        //log.debug("=== 请求头详情 ===");
        for (Map.Entry<String, String> entry : headers.entrySet()) {
            //log.debug("{}: {}", entry.getKey(), entry.getValue());
        }
        //log.debug("================");
    }
    
    /**
     * 记录请求执行详情
     * 
     * @param url 请求URL
     * @param method 请求方法
     * @param timeout 超时时间
     * @param retryCount 重试次数
     */
    private void logRequestExecutionDetails(String url, String method, int timeout, int retryCount) {
        //log.debug("=== 请求执行详情 ===");
        //log.debug("URL: {}", url);
        //log.debug("方法: {}", method);
        //log.debug("超时: {}ms", timeout);
        //log.debug("重试次数: {}", retryCount);
        //log.debug("==================");
    }
    
    /**
     * 记录响应详情
     * 
     * @param response 响应对象
     * @param responseBody 响应体
     */
    private void logResponseDetails(HttpResponse response, String responseBody) {
        if (response != null) {
            //log.debug("=== 响应详情 ===");
            //log.debug("状态码: {}", response.getStatus());
            //log.debug("响应头: {}", response.headers());
            //log.debug("响应体: {}", responseBody);
            //log.debug("==============");
        }
    }
}