package com.ssyf.task.models;

import com.ssyf.module.robot.domain.entity.RConfigRelation;
import com.ssyf.module.robot.domain.entity.RRobotAccount;
import com.ssyf.module.robot.domain.entity.RRunningConfig;
import com.ssyf.third.bmiss.model.LoginResponse;
import com.ssyf.third.bmiss.model.UserInfo;
import lombok.extern.slf4j.Slf4j;

/**
 * 机器人任务上下文管理类
 * 使用ThreadLocal管理线程上下文数据，包含登录用户信息的管理
 * 
 * @author system
 * @since 1.0
 */
@Slf4j
public class RobotTaskContext {
    
    /**
     * ThreadLocal存储当前线程的登录响应数据
     */
    private static final ThreadLocal<LoginResponse> LOGIN_CONTEXT = new ThreadLocal<>();
    
    /**
     * ThreadLocal存储当前线程的用户信息
     */
    private static final ThreadLocal<UserInfo> USER_CONTEXT = new ThreadLocal<>();
    
    /**
     * ThreadLocal存储当前线程的机器人账号ID
     */
    private static final ThreadLocal<String> ROBOT_ACCOUNT_ID = new ThreadLocal<>();
    
    /**
     * ThreadLocal存储当前线程的配置关联ID
     */
    private static final ThreadLocal<String> CONFIG_RELATION_ID = new ThreadLocal<>();
    
    /**
     * ThreadLocal存储当前线程的任务ID
     */
    private static final ThreadLocal<String> TASK_ID = new ThreadLocal<>();
    
    /**
     * ThreadLocal存储当前线程的机器人账号对象
     */
    private static final ThreadLocal<RRobotAccount> ROBOT_ACCOUNT = new ThreadLocal<>();
    
    /**
     * ThreadLocal存储当前线程的配置关联对象
     */
    private static final ThreadLocal<RConfigRelation> CONFIG_RELATION = new ThreadLocal<>();
    
    /**
     * ThreadLocal存储当前线程的运行配置对象
     */
    private static final ThreadLocal<RRunningConfig> RUNNING_CONFIG = new ThreadLocal<>();
    
    /**
     * 设置当前线程的登录响应数据
     * 
     * @param loginResponse 登录响应数据
     */
    public static void setLoginResponse(LoginResponse loginResponse) {
        if (loginResponse == null) {
            log.warn("尝试设置空的登录响应数据到线程上下文");
            return;
        }
        LOGIN_CONTEXT.set(loginResponse);
        log.debug("已设置登录响应数据到线程上下文");
    }
    
    /**
     * 获取当前线程的登录响应数据
     * 
     * @return 登录响应数据，如果不存在则返回null
     */
    public static LoginResponse getLoginResponse() {
        LoginResponse loginResponse = LOGIN_CONTEXT.get();
        if (loginResponse == null) {
            log.debug("线程上下文中未找到登录响应数据");
        }
        return loginResponse;
    }
    
    /**
     * 设置当前线程的用户信息
     * 
     * @param userInfo 用户信息
     */
    public static void setUserInfo(UserInfo userInfo) {
        if (userInfo == null) {
            log.warn("尝试设置空的用户信息到线程上下文");
            return;
        }
        USER_CONTEXT.set(userInfo);
        log.debug("已设置用户信息到线程上下文");
    }
    
    /**
     * 获取当前线程的用户信息
     * 
     * @return 用户信息，如果不存在则返回null
     */
    public static UserInfo getUserInfo() {
        UserInfo userInfo = USER_CONTEXT.get();
        if (userInfo == null) {
            log.debug("线程上下文中未找到用户信息");
        }
        return userInfo;
    }
    
    /**
     * 设置当前线程的机器人账号ID
     * 
     * @param robotAccountId 机器人账号ID
     */
    public static void setRobotAccountId(String robotAccountId) {
        if (robotAccountId == null || robotAccountId.trim().isEmpty()) {
            log.warn("尝试设置空的机器人账号ID到线程上下文");
            return;
        }
        ROBOT_ACCOUNT_ID.set(robotAccountId);
        log.debug("已设置机器人账号ID到线程上下文: {}", robotAccountId);
    }
    
    /**
     * 获取当前线程的机器人账号ID
     * 
     * @return 机器人账号ID，如果不存在则返回null
     */
    public static String getRobotAccountId() {
        String robotAccountId = ROBOT_ACCOUNT_ID.get();
        if (robotAccountId == null) {
            log.debug("线程上下文中未找到机器人账号ID");
        }
        return robotAccountId;
    }
    
    /**
     * 设置当前线程的配置关联ID
     * 
     * @param configRelationId 配置关联ID
     */
    public static void setConfigRelationId(String configRelationId) {
        if (configRelationId == null || configRelationId.trim().isEmpty()) {
            log.warn("尝试设置空的配置关联ID到线程上下文");
            return;
        }
        CONFIG_RELATION_ID.set(configRelationId);
        log.debug("已设置配置关联ID到线程上下文: {}", configRelationId);
    }
    
    /**
     * 获取当前线程的配置关联ID
     * 
     * @return 配置关联ID，如果不存在则返回null
     */
    public static String getConfigRelationId() {
        String configRelationId = CONFIG_RELATION_ID.get();
        if (configRelationId == null) {
            log.debug("线程上下文中未找到配置关联ID");
        }
        return configRelationId;
    }
    
    /**
     * 设置当前线程的任务ID
     * 
     * @param taskId 任务ID
     */
    public static void setTaskId(String taskId) {
        if (taskId == null || taskId.trim().isEmpty()) {
            log.warn("尝试设置空的任务ID到线程上下文");
            return;
        }
        TASK_ID.set(taskId);
        log.debug("已设置任务ID到线程上下文: {}", taskId);
    }
    
    /**
     * 获取当前线程的任务ID
     * 
     * @return 任务ID，如果不存在则返回null
     */
    public static String getTaskId() {
        String taskId = TASK_ID.get();
        if (taskId == null) {
            log.debug("线程上下文中未找到任务ID");
        }
        return taskId;
    }
    
    /**
     * 设置当前线程的机器人账号对象
     * 
     * @param robotAccount 机器人账号对象
     */
    public static void setRobotAccount(RRobotAccount robotAccount) {
        if (robotAccount == null) {
            log.warn("尝试设置空的机器人账号对象到线程上下文");
            return;
        }
        ROBOT_ACCOUNT.set(robotAccount);
        log.debug("已设置机器人账号对象到线程上下文");
    }
    
    /**
     * 获取当前线程的机器人账号对象
     * 
     * @return 机器人账号对象，如果不存在则返回null
     */
    public static RRobotAccount getRobotAccount() {
        RRobotAccount robotAccount = ROBOT_ACCOUNT.get();
        if (robotAccount == null) {
            log.debug("线程上下文中未找到机器人账号对象");
        }
        return robotAccount;
    }
    
    /**
     * 设置当前线程的配置关联对象
     * 
     * @param configRelation 配置关联对象
     */
    public static void setConfigRelation(RConfigRelation configRelation) {
        if (configRelation == null) {
            log.warn("尝试设置空的配置关联对象到线程上下文");
            return;
        }
        CONFIG_RELATION.set(configRelation);
        log.debug("已设置配置关联对象到线程上下文");
    }
    
    /**
     * 获取当前线程的配置关联对象
     * 
     * @return 配置关联对象，如果不存在则返回null
     */
    public static RConfigRelation getConfigRelation() {
        RConfigRelation configRelation = CONFIG_RELATION.get();
        if (configRelation == null) {
            log.debug("线程上下文中未找到配置关联对象");
        }
        return configRelation;
    }
    
    /**
     * 设置当前线程的运行配置对象
     * 
     * @param runningConfig 运行配置对象
     */
    public static void setRunningConfig(RRunningConfig runningConfig) {
        if (runningConfig == null) {
            log.warn("尝试设置空的运行配置对象到线程上下文");
            return;
        }
        RUNNING_CONFIG.set(runningConfig);
        log.debug("已设置运行配置对象到线程上下文");
    }
    
    /**
     * 获取当前线程的运行配置对象
     * 
     * @return 运行配置对象，如果不存在则返回null
     */
    public static RRunningConfig getRunningConfig() {
        RRunningConfig runningConfig = RUNNING_CONFIG.get();
        if (runningConfig == null) {
            log.debug("线程上下文中未找到运行配置对象");
        }
        return runningConfig;
    }
    
    /**
     * 获取当前线程的登录令牌
     * 
     * @return 登录令牌，如果不存在则返回null
     */
    public static String getToken() {
        LoginResponse loginResponse = getLoginResponse();
        if (loginResponse == null) {
            return null;
        }
        return loginResponse.getToken();
    }
    
    /**
     * 获取当前线程的用户ID
     * 
     * @return 用户ID，如果不存在则返回null
     */
    public static String getUserId() {
        UserInfo userInfo = getUserInfo();
        if (userInfo == null) {
            return null;
        }
        return userInfo.getUser_id();
    }
    
    /**
     * 获取当前线程的用户编号
     * 
     * @return 用户编号，如果不存在则返回null
     */
    public static String getUserNumber() {
        UserInfo userInfo = getUserInfo();
        if (userInfo == null) {
            return null;
        }
        return userInfo.getUser_number();
    }
    
    /**
     * 检查当前线程是否已登录
     * 
     * @return true表示已登录，false表示未登录
     */
    public static boolean isLoggedIn() {
        return getToken() != null && getUserId() != null;
    }
    
    /**
     * 清除当前线程的所有上下文数据
     */
    public static void clear() {
        LOGIN_CONTEXT.remove();
        USER_CONTEXT.remove();
        ROBOT_ACCOUNT_ID.remove();
        CONFIG_RELATION_ID.remove();
        TASK_ID.remove();
        ROBOT_ACCOUNT.remove();
        CONFIG_RELATION.remove();
        RUNNING_CONFIG.remove();
        log.debug("已清除线程上下文数据");
    }
    
    /**
     * 清除当前线程的登录相关数据
     */
    public static void clearLoginData() {
        LOGIN_CONTEXT.remove();
        USER_CONTEXT.remove();
        log.debug("已清除线程登录相关数据");
    }
    
    /**
     * 清除当前线程的任务相关数据
     */
    public static void clearTaskData() {
        ROBOT_ACCOUNT_ID.remove();
        CONFIG_RELATION_ID.remove();
        TASK_ID.remove();
        ROBOT_ACCOUNT.remove();
        CONFIG_RELATION.remove();
        RUNNING_CONFIG.remove();
        log.debug("已清除线程任务相关数据");
    }
    
    /**
     * 初始化线程上下文（无参版本）
     * 在任务开始执行时调用，仅初始化上下文环境
     */
    public static void initContext() {
        log.debug("线程上下文环境初始化完成");
    }
    
    /**
     * 初始化线程上下文
     * 在任务开始执行时调用，设置基本的上下文信息
     * 
     * @param robotAccountId 机器人账号ID
     * @param configRelationId 配置关联ID
     * @param taskId 任务ID
     */
    public static void initContext(String robotAccountId, String configRelationId, String taskId) {
        setRobotAccountId(robotAccountId);
        setConfigRelationId(configRelationId);
        setTaskId(taskId);
        log.debug("线程上下文初始化完成，机器人账号ID: {}, 配置关联ID: {}, 任务ID: {}",
                robotAccountId, configRelationId, taskId);
    }
    
    /**
     * 设置登录上下文
     * 在登录成功后调用，设置登录相关的上下文信息
     * 
     * @param loginResponse 登录响应数据
     */
    public static void setLoginContext(LoginResponse loginResponse) {
        if (loginResponse == null) {
            log.warn("尝试设置空的登录上下文");
            return;
        }
        
        setLoginResponse(loginResponse);
        
        // 如果登录响应中包含用户信息，则设置用户信息
        if (loginResponse.getUser_info() != null) {
            setUserInfo(loginResponse.getUser_info());
        }
        
        log.debug("登录上下文设置完成，用户ID: {}, 令牌: {}",
                getUserId(), getToken());
    }
    
    /**
     * 获取当前线程上下文的摘要信息
     * 
     * @return 上下文摘要信息
     */
    public static String getContextSummary() {
        StringBuilder summary = new StringBuilder();
        summary.append("RobotTaskContext Summary:\n");
        summary.append("  Logged In: ").append(isLoggedIn()).append("\n");
        summary.append("  User ID: ").append(getUserId()).append("\n");
        summary.append("  User Number: ").append(getUserNumber()).append("\n");
        summary.append("  Robot Account ID: ").append(getRobotAccountId()).append("\n");
        summary.append("  Config Relation ID: ").append(getConfigRelationId()).append("\n");
        summary.append("  Task ID: ").append(getTaskId()).append("\n");
        summary.append("  Robot Account Object: ").append(getRobotAccount() != null ? "Present" : "Null").append("\n");
        summary.append("  Config Relation Object: ").append(getConfigRelation() != null ? "Present" : "Null").append("\n");
        summary.append("  Running Config Object: ").append(getRunningConfig() != null ? "Present" : "Null").append("\n");
        
        return summary.toString();
    }
}