package com.ssyf.module.robot.domain.strategy;

import com.ssyf.module.robot.domain.entity.ChatConfig;
import com.ssyf.third.doubao.DoubaoService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.concurrent.CompletableFuture;

/**
 * AI聊天策略
 * 使用AI生成内容进行聊天
 */
@Slf4j
@Component
public class AIChatStrategy implements ChatStrategy {
    
    @Autowired
    private DoubaoService doubaoService;
    
    @Override
    public boolean canChat(ChatConfig config, ChatContext context) {
        // AI聊天策略需要配置启用且AI开关打开
        if (config == null || config.getStatus() != 1 || config.getAiSwitch() != 1) {
            return false;
        }
        
        // 检查聊天频率控制
        return checkChatFrequency(config, context);
    }
    
    /**
     * 检查聊天频率控制
     * @param config 聊天配置
     * @param context 聊天上下文
     * @return 是否可以聊天
     */
    private boolean checkChatFrequency(ChatConfig config, ChatContext context) {
        // 检查聊天次数限制
        if (config.getCount() != null && config.getCount() > 0) {
            Integer currentCount = context.getChatCount() != null ? context.getChatCount() : 0;
            if (currentCount >= config.getCount()) {
                log.debug("聊天次数已达上限：{}/{}", currentCount, config.getCount());
                return false;
            }
        }
        
        // 检查聊天间隔时间
        if (config.getMinIntervalTime() != null && config.getMaxIntervalTime() != null) {
            Long lastChatTime = context.getLastChatTime();
            if (lastChatTime != null) {
                long currentTime = System.currentTimeMillis();
                long elapsedTime = (currentTime - lastChatTime) / 1000; // 转换为秒
                
                // 如果距离上次聊天时间太短，则不能聊天
                if (elapsedTime < config.getMinIntervalTime()) {
                    log.debug("聊天间隔时间太短：{}秒 < {}秒", elapsedTime, config.getMinIntervalTime());
                    return false;
                }
                
                // 如果距离上次聊天时间超过最大间隔，则必须聊天（防止长时间不聊天）
                if (elapsedTime >= config.getMaxIntervalTime()) {
                    log.debug("聊天间隔时间已超过最大值：{}秒 >= {}秒，必须聊天", elapsedTime, config.getMaxIntervalTime());
                    return true;
                }
                
                // 在最小和最大间隔之间，随机决定是否聊天
                double probability = (double) (elapsedTime - config.getMinIntervalTime()) / 
                                   (config.getMaxIntervalTime() - config.getMinIntervalTime());
                boolean shouldChat = Math.random() < probability;
                
                log.debug("聊天概率计算：间隔{}秒，概率{:.2f}%，结果：{}", 
                         elapsedTime, probability * 100, shouldChat);
                return shouldChat;
            }
        }
        
        // 如果没有设置间隔时间限制，或者这是第一次聊天，则允许聊天
        return true;
    }
    
    @Override
    public void getChatContentAsync(ChatConfig config, ChatContext context, ChatCallback callback) {
        log.debug("AI聊天策略异步获取聊天内容开始: Config={}, Context={}", 
                 config != null ? config.getUuid() : "null", 
                 context != null ? context.getLiveRoomId() : "null");
        
        try {
            // 获取机器人名称（从上下文或配置中获取）
            String robotName = getRobotName(context);
            
            log.debug("调用豆包AI服务: Robot={}, contextMessage={}", robotName, context.getMessage());
            
            // 异步调用豆包AI服务
            CompletableFuture<String> aiResponseFuture = doubaoService.sendInteractionAsync(robotName, context.getMessage());
            
            // 处理异步结果
            aiResponseFuture.whenComplete((aiResponse, throwable) -> {
                if (throwable != null) {
                    log.error("豆包AI服务调用异常", throwable);
                    callback.onChatContent(null);
                    return;
                }
                
                if (aiResponse == null) {
                    log.debug("豆包AI服务返回频控，不发送消息");
                    callback.onChatContent(null);
                    return;
                }

                
                log.debug("AI聊天策略异步获取聊天内容完成: Response={}", aiResponse);
                
                // 调用回调
                callback.onChatContent(aiResponse);
            });
            
        } catch (Exception e) {
            log.error("AI聊天策略异步获取聊天内容异常", e);
            // 异常时回调null
            callback.onChatContent(null);
        }
    }
    
    /**
     * 获取机器人名称
     * @param context 聊天上下文
     * @return 机器人名称
     */
    private String getRobotName(ChatContext context) {
        return context.getRobotName();
    }
    
    @Override
    public ChatStrategyType getStrategyType() {
        return ChatStrategyType.AI;
    }

}