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

import com.ssyf.module.robot.domain.entity.ChatConfig;
import com.ssyf.module.robot.domain.entity.MessageTemplate;
import com.ssyf.module.robot.domain.query.MessageTemplateQuery;
import com.ssyf.module.robot.service.MessageTemplateService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.Random;

/**
 * 模板聊天策略
 * 使用预设的模板内容进行聊天
 */
@Slf4j
@Component
public class TemplateChatStrategy implements ChatStrategy {
    
    @Autowired
    private MessageTemplateService messageTemplateService;
    
    private final Random random = new Random();
    
    @Override
    public boolean canChat(ChatConfig config, ChatContext context) {
        // 模板聊天策略需要配置启用
        if (config == null || config.getStatus() != 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;
    }
    
    public String getChatContent(ChatConfig config, ChatContext context) {
        if (config == null) {
            log.warn("聊天配置为空，无法获取聊天内容");
            return null;
        }

        try {
            // 获取可用的消息模板（使用聊天类型的模板）
            List<MessageTemplate> templates = messageTemplateService.getList(new MessageTemplateQuery());
            if (templates.isEmpty()) {
                log.warn("没有可用的消息模板");
                return null;
            }

            // 随机选择一个模板
            MessageTemplate template = templates.get(random.nextInt(templates.size()));

            // 替换模板中的变量
            return replaceTemplateVariables(template.getContent(), context);

        } catch (Exception e) {
            log.error("获取模板聊天内容时发生异常", e);
            return null;
        }
    }
    
    @Override
    public void getChatContentAsync(ChatConfig config, ChatContext context, ChatCallback callback) {
        log.debug("模板聊天策略异步获取聊天内容开始: Config={}, Context={}", 
                 config != null ? config.getUuid() : "null", 
                 context != null ? context.getLiveRoomId() : "null");
        
        try {
            // 模板聊天是同步的，直接调用同步方法并回调
            String chatContent = getChatContent(config, context);
            
            log.debug("模板聊天策略异步获取聊天内容完成: Content={}", chatContent);
            
            // 调用回调
            callback.onChatContent(chatContent);
            
        } catch (Exception e) {
            log.error("模板聊天策略异步获取聊天内容异常", e);
            // 异常时回调null
            callback.onChatContent(null);
        }
    }
    
    @Override
    public ChatStrategyType getStrategyType() {
        return ChatStrategyType.TEMPLATE;
    }
    
    /**
     * 替换模板中的变量
     * @param templateContent 模板内容
     * @param context 聊天上下文
     * @return 替换后的内容
     */
    private String replaceTemplateVariables(String templateContent, ChatContext context) {
        if (templateContent == null || context == null) {
            return templateContent;
        }
        
        String result = templateContent;
        
        // 替换直播间相关变量
        if (context.getLiveRoomName() != null) {
            result = result.replace("{直播间名称}", context.getLiveRoomName());
        }
        
        if (context.getAnchorName() != null) {
            result = result.replace("{主播名称}", context.getAnchorName());
        }
        
        if (context.getOnlineUsers() != null) {
            result = result.replace("{在线人数}", context.getOnlineUsers().toString());
        }
        
        // 替换通用变量
        result = result.replace("{时间}", java.time.LocalDateTime.now().format(java.time.format.DateTimeFormatter.ofPattern("HH:mm")));
        
        return result;
    }
}