package com.ssyf.third.doubao;

import cn.hutool.core.util.StrUtil;
import cn.hutool.http.HttpRequest;
import cn.hutool.http.HttpResponse;
import cn.hutool.json.JSONUtil;
import com.ssyf.third.doubao.model.DoubaoRequest;
import com.ssyf.third.doubao.model.DoubaoResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

import java.util.concurrent.CompletableFuture;

/**
 * 豆包AI服务类
 */
@Slf4j
@Service
public class DoubaoService {

    @Autowired
    private DoubaoProperties doubaoProperties;

    @Autowired
    private DoubaoTemplate doubaoTemplate;

    /**
     * 异步发送互动信息到豆包AI
     *
     * @param userName        用户名称
     * @param interactionInfo 互动信息
     * @return 异步结果，包含AI生成的回复内容，频控时返回null
     */
    @Async
    public CompletableFuture<String> sendInteractionAsync(String userName, String interactionInfo) {
        return CompletableFuture.supplyAsync(() -> {
            try {
                if (!doubaoProperties.isEnabled()) {
                    log.warn("豆包AI服务未启用，跳过调用");
                    return null;
                }

                // 构建完整的提示词
                String fullPrompt = doubaoTemplate.getFullPrompt(userName, interactionInfo);

                // 构建请求对象
                DoubaoRequest request = DoubaoRequest.create(doubaoProperties.getModel(), fullPrompt);

                log.debug("发送豆包AI请求，用户: {}, 内容长度: {}", userName, fullPrompt.length());

                // 发送HTTP请求
                HttpResponse response = HttpRequest.post(doubaoProperties.getEndpoint())
                        .header("Authorization", "Bearer " + doubaoProperties.getApiKey())
                        .header("Content-Type", "application/json")
                        .body(JSONUtil.toJsonStr(request))
                        .timeout(doubaoProperties.getTimeout())
                        .execute();

                if (response.getStatus() == 200) {
                    String responseBody = response.body();
                    log.debug("豆包AI响应成功，用户: {}, 响应: {}", userName, responseBody);

                    // 解析响应
                    return parseResponse(responseBody);
                } else {
                    log.error("豆包AI请求失败，状态码: {}, 响应: {}", response.getStatus(), response.body());
                    return null;
                }

            } catch (Exception e) {
                log.error("豆包AI调用异常，用户: {}", userName, e);
                return null;
            }
        });
    }

    /**
     * 解析豆包AI响应
     *
     * @param responseBody 响应体
     * @return 解析后的回复内容，频控时返回null
     */
    private String parseResponse(String responseBody) {
        try {
            log.debug("开始解析豆包AI响应: {}", responseBody);

            // 解析完整的响应结构
            DoubaoResponse doubaoResponse = JSONUtil.toBean(responseBody, DoubaoResponse.class);

            if (doubaoResponse == null || doubaoResponse.getOutput() == null) {
                log.warn("豆包AI响应格式异常，无法解析output字段");
                return null;
            }

            // 遍历输出项，查找assistant类型的消息
            for (DoubaoResponse.OutputItem outputItem : doubaoResponse.getOutput()) {
                if ("message".equals(outputItem.getType()) && "assistant".equals(outputItem.getRole())) {
                    // 查找content中的文本内容
                    if (outputItem.getContent() != null) {
                        for (DoubaoResponse.Content content : outputItem.getContent()) {
                            if ("output_text".equals(content.getType()) && content.getText() != null) {
                                String output = content.getText().trim();
                                String context = parseContext(output);
                                if(context != null){
                                    return context;
                                }
                            }
                        }
                    }
                }
            }

            // 如果没有找到有效的回复内容，检查reasoning中的summary
            for (DoubaoResponse.OutputItem outputItem : doubaoResponse.getOutput()) {
                if ("reasoning".equals(outputItem.getType()) && outputItem.getSummary() != null) {
                    // 检查summary中的文本内容
                    if (outputItem.getSummary().getSummary() != null) {
                        for (DoubaoResponse.SummaryText summaryText : outputItem.getSummary().getSummary()) {
                            if ("summary_text".equals(summaryText.getType()) && summaryText.getText() != null) {
                                String summary = summaryText.getText().trim();
                                String context = parseContext(summary);
                                if(context != null){
                                    return context;
                                }
                            }
                        }
                    }
                }
            }

            log.warn("未在豆包AI响应中找到有效的回复内容");

        } catch (Exception e) {
            log.error("解析豆包AI响应异常", e);
        }

        return null;
    }


    private String parseContext(String contextString) {
        if(StrUtil.isBlank(contextString) || StrUtil.isBlank(contextString.trim())){
            return null;
        }
        String output = contextString;

// 尝试将 output 解析为 JSON 对象
        try {
            // 使用 Hutool 的 JSON 工具解析字符串
            cn.hutool.json.JSONObject jsonObject = JSONUtil.parseObj(output);

            // 判断是否存在 context 字段（发言内容）
            if (jsonObject.containsKey("context")) {
                String context = jsonObject.getStr("context");
                if (context != null && !context.isEmpty()) {
                    log.debug("成功解析豆包AI回复 (context): {}", context);
                    return context;
                }
            }

            // 判断是否存在 msg 字段（错误信息或频控信息）
            if (jsonObject.containsKey("msg")) {
                String msg = jsonObject.getStr("msg");
                if (msg != null && !msg.isEmpty()) {
                    // 其他错误信息可按需处理
                    log.warn("豆包AI返回错误信息: {}", msg);
                    return null;
                }
            }

            // 如果既没有 context 也没有 msg，则记录警告
            log.warn("豆包AI响应格式异常，未找到有效字段: {}", output);

        } catch (Exception e) {
            // 解析 JSON 失败时记录日志
            log.error("解析豆包AI响应内容失败: {}", output, e);
        }

// 默认返回 null
        return null;

    }

    /**
     * 同步发送互动信息（用于测试或简单场景）
     *
     * @param userName        用户名称
     * @param interactionInfo 互动信息
     * @return AI生成的回复内容，频控时返回null
     */
    public String sendInteraction(String userName, String interactionInfo) {
        try {
            return sendInteractionAsync(userName, interactionInfo).get();
        } catch (Exception e) {
            log.error("同步调用豆包AI异常，用户: {}", userName, e);
            return null;
        }
    }
}