package com.example.auth.core.model;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

/**
 * 设备信息模型
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class DeviceInfo implements Serializable {

	/**
	 * JWT ID（设备唯一标识）
	 */
	private String jti;

	/**
	 * 设备类型（Mobile / Desktop / Tablet）
	 */
	private String deviceType;

	/**
	 * 操作系统（如 iOS 17.2, Windows 11）
	 */
	private String os;

	/**
	 * 浏览器（如 Chrome 120, Safari 17）
	 */
	private String browser;

	/**
	 * IP 地址
	 */
	private String ip;

	/**
	 * 登录时间（时间戳，秒）
	 */
	private Long loginTime;

	/**
	 * 登录时间（格式化字符串）
	 */
	private String loginTimeFormatted;
}

package com.example.auth.core.util;

import cn.hutool.core.util.StrUtil;
import cn.hutool.http.useragent.UserAgent;
import cn.hutool.http.useragent.UserAgentUtil;
import jakarta.servlet.http.HttpServletRequest;
import lombok.extern.slf4j.Slf4j;

/**
 * 设备信息提取工具类
 * <p>
 * 用于从 HTTP 请求中提取客户端设备相关信息，包括设备类型、操作系统、浏览器和 IP 地址等。
 * </p>
 */
@Slf4j
public class DeviceInfoExtractor {

	/**
	 * 从请求中提取设备类型
	 *
	 * @param request HTTP 请求对象
	 * @return 设备类型：Mobile（手机）、Tablet（平板）、Desktop（桌面）或 Unknown（未知）
	 */
	public static String extractDeviceType(HttpServletRequest request) {
		String userAgentStr = request.getHeader("User-Agent");
		if (StrUtil.isBlank(userAgentStr)) {
			return "Unknown";
		}
		UserAgent ua = UserAgentUtil.parse(userAgentStr);
		if (ua.isMobile()) {
			return "Mobile";
		} else if (isTablet(userAgentStr)) {
			return "Tablet";
		} else {
			return "Desktop";
		}
	}

	/**
	 * 从请求中提取操作系统信息
	 *
	 * @param request HTTP 请求对象
	 * @return 操作系统名称，如 Windows、Mac OS X、Android、iOS 等，未知时返回 Unknown
	 */
	public static String extractOs(HttpServletRequest request) {
		String userAgentStr = request.getHeader("User-Agent");
		if (StrUtil.isBlank(userAgentStr)) {
			return "Unknown";
		}
		UserAgent ua = UserAgentUtil.parse(userAgentStr);
		return ua.getOs().getName();
	}

	/**
	 * 从请求中提取浏览器信息
	 *
	 * @param request HTTP 请求对象
	 * @return 浏览器名称和版本号，如 Chrome 120.0，未知时返回 Unknown
	 */
	public static String extractBrowser(HttpServletRequest request) {
		String userAgentStr = request.getHeader("User-Agent");
		if (StrUtil.isBlank(userAgentStr)) {
			return "Unknown";
		}
		UserAgent ua = UserAgentUtil.parse(userAgentStr);
		return ua.getBrowser().getName() + " " + ua.getVersion();
	}

	/**
	 * 从请求中提取客户端真实 IP 地址
	 * <p>
	 * 优先从代理相关请求头中获取真实 IP，支持以下请求头（按优先级）：
	 * <ul>
	 *     <li>X-Forwarded-For：标准的代理转发头，取第一个 IP</li>
	 *     <li>X-Real-IP：Nginx 代理常用头</li>
	 *     <li>Proxy-Client-IP：Apache 代理头</li>
	 *     <li>WL-Proxy-Client-IP：WebLogic 代理头</li>
	 * </ul>
	 * 如果以上请求头都不存在，则使用 {@link HttpServletRequest#getRemoteAddr()} 获取。
	 * </p>
	 *
	 * @param request HTTP 请求对象
	 * @return 客户端真实 IP 地址
	 */
	public static String extractIp(HttpServletRequest request) {
		String ip = request.getHeader("X-Forwarded-For");
		if (isValidIp(ip)) {
			return ip.split(",")[0].trim();
		}
		ip = request.getHeader("X-Real-IP");
		if (isValidIp(ip)) {
			return ip;
		}
		ip = request.getHeader("Proxy-Client-IP");
		if (isValidIp(ip)) {
			return ip;
		}
		ip = request.getHeader("WL-Proxy-Client-IP");
		if (isValidIp(ip)) {
			return ip;
		}
		return request.getRemoteAddr();
	}

	/**
	 * 校验 IP 地址是否有效
	 *
	 * @param ip IP 地址字符串
	 * @return 如果 IP 地址非空且不为 "unknown" 则返回 true，否则返回 false
	 */
	private static boolean isValidIp(String ip) {
		return StrUtil.isNotBlank(ip) && !"unknown".equalsIgnoreCase(ip);
	}

	/**
	 * 判断设备是否为平板电脑
	 * <p>
	 * 通过 User-Agent 字符串判断设备是否为平板，支持以下设备识别：
	 * <ul>
	 *     <li>iPad</li>
	 *     <li>Android 平板（包含 android 但不包含 mobile）</li>
	 *     <li>其他平板关键词：tablet、kindle、silk、playbook</li>
	 * </ul>
	 * </p>
	 *
	 * @param userAgentStr User-Agent 字符串
	 * @return 如果是平板设备返回 true，否则返回 false
	 */
	private static boolean isTablet(String userAgentStr) {
		String ua = userAgentStr.toLowerCase();
		if (ua.contains("ipad")) {
			return true;
		}
		if (ua.contains("android") && !ua.contains("mobile")) {
			return true;
		}
		return ua.contains("tablet")
				|| ua.contains("kindle")
				|| ua.contains("silk")
				|| ua.contains("playbook");
	}
}

package com.example.auth.core.constant;

public class RedisKeyConstants {
  // ...原有内容

	/**
	 * 设备详情 Key 前缀（Hash）
	 */
	public static final String DEVICE_INFO_PREFIX = "auth:device:";
	

	/**
	 * 构建设备详情 Key
	 */
	public static String buildDeviceInfoKey(String jti) {
		return DEVICE_INFO_PREFIX + jti;
	}
}

package com.example.auth.core.manager;

import cn.hutool.core.date.DateUtil;
import com.example.auth.core.constant.RedisKeyConstants;
import com.example.auth.core.model.DeviceInfo;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.util.*;

/**
 * Token Redis 管理器（基础设施层）
 * <p>
 * 职责：只负责 Token 在 Redis 中的 CRUD 操作，不包含业务逻辑判断。
 * 这是一个"底层苦力"，只有存取方法，没有复杂的 if-else。
 * </p>
 */
@Slf4j
@Component
@RequiredArgsConstructor
public class TokenRedisManager {

	private final StringRedisTemplate redisTemplate;

	/**
	 * 存储 Refresh Token 和设备信息（使用 Pipeline 批量操作）
	 */
	public void saveRefreshToken(Long userId, String refreshToken,
	                             String jti, long expireSeconds, DeviceInfo deviceInfo) {
		redisTemplate.executePipelined((RedisCallback<Object>) connection -> {

			// 1. 存储 Refresh Token (K = refreshToken, V = userId)
			String refreshKey = RedisKeyConstants.buildRefreshTokenKey(refreshToken);
			connection.stringCommands().setEx(
					refreshKey.getBytes(),
					expireSeconds,
					userId.toString().getBytes()
			);

			// 2. 将设备加入用户的在线设备列表（ZSet，按登录时间排序）
			String userKey = RedisKeyConstants.buildUserOnlineKey(userId);
			double score = deviceInfo.getLoginTime().doubleValue();
			connection.zSetCommands().zAdd(
					userKey.getBytes(),
					score,
					jti.getBytes()
			);

			// 3. 给设备列表设置过期时间
			connection.keyCommands().expire(
					userKey.getBytes(),
					expireSeconds
			);

			// 4. 存储设备详情（Hash）
			String deviceKey = RedisKeyConstants.buildDeviceInfoKey(jti);
			Map<byte[], byte[]> deviceMap = new HashMap<>();
			deviceMap.put("jti".getBytes(), jti.getBytes());
			deviceMap.put("deviceType".getBytes(), deviceInfo.getDeviceType().getBytes());
			deviceMap.put("os".getBytes(), deviceInfo.getOs().getBytes());
			deviceMap.put("browser".getBytes(), deviceInfo.getBrowser().getBytes());
			deviceMap.put("ip".getBytes(), deviceInfo.getIp().getBytes());
			deviceMap.put("loginTime".getBytes(), deviceInfo.getLoginTime().toString().getBytes());
			connection.hashCommands().hMSet(deviceKey.getBytes(), deviceMap);

			// 5. 给设备详情设置过期时间
			connection.keyCommands().expire(
					deviceKey.getBytes(),
					expireSeconds
			);

			return null;
		});

		log.debug("存储 Refresh Token 和设备信息成功: userId={}, jti={}, 设备类型={}, 有效期={}秒",
				userId, jti, deviceInfo.getDeviceType(), expireSeconds);
	}

	/**
	 * 根据 Refresh Token 获取用户 ID
	 */
	public Long getUserIdByRefreshToken(String refreshToken) {
		String key = RedisKeyConstants.buildRefreshTokenKey(refreshToken);
		String userId = redisTemplate.opsForValue().get(key);
		return userId == null ? null : Long.parseLong(userId);
	}

	/**
	 * 删除 Refresh Token
	 */
	public void deleteRefreshToken(String refreshToken) {
		String key = RedisKeyConstants.buildRefreshTokenKey(refreshToken);
		redisTemplate.delete(key);
		log.debug("删除 Refresh Token: {}", refreshToken);
	}

	/**
	 * 获取用户的所有在线设备（按登录时间排序）
	 */
	public List<DeviceInfo> getUserOnlineDevices(Long userId) {
		String userKey = RedisKeyConstants.buildUserOnlineKey(userId);

		// 1. 从 ZSet 中获取所有 JTI（按登录时间倒序）
		Set<String> jtiSet = redisTemplate.opsForZSet().reverseRange(userKey, 0, -1);

		if (jtiSet == null || jtiSet.isEmpty()) {
			return Collections.emptyList();
		}

		// 2. 批量获取设备详情
		return jtiSet.stream()
				.map(this::getDeviceInfo)
				.filter(Objects::nonNull)
				.toList();
	}

	/**
	 * 获取设备详情
	 */
	public DeviceInfo getDeviceInfo(String jti) {
		String deviceKey = RedisKeyConstants.buildDeviceInfoKey(jti);
		Map<Object, Object> deviceMap = redisTemplate.opsForHash().entries(deviceKey);

		if (deviceMap.isEmpty()) {
			return null;
		}

		Long loginTime = Long.parseLong((String) deviceMap.get("loginTime"));

		return DeviceInfo.builder()
				.jti((String) deviceMap.get("jti"))
				.deviceType((String) deviceMap.get("deviceType"))
				.os((String) deviceMap.get("os"))
				.browser((String) deviceMap.get("browser"))
				.ip((String) deviceMap.get("ip"))
				.loginTime(loginTime)
				.loginTimeFormatted(DateUtil.formatDateTime(new Date(loginTime * 1000)))
				.build();
	}

	/**
	 * 从用户在线设备列表中移除指定设备
	 */
	public void removeUserDevice(Long userId, String jti) {
		// 1. 从 ZSet 中移除
		String userKey = RedisKeyConstants.buildUserOnlineKey(userId);
		redisTemplate.opsForZSet().remove(userKey, jti);

		// 2. 删除设备详情
		String deviceKey = RedisKeyConstants.buildDeviceInfoKey(jti);
		redisTemplate.delete(deviceKey);

		log.debug("移除用户设备: userId={}, jti={}", userId, jti);
	}

	/**
	 * 清空用户的所有在线设备
	 */
	public void clearUserDevices(Long userId) {
		String userKey = RedisKeyConstants.buildUserOnlineKey(userId);

		// 1. 获取所有 JTI
		Set<String> jtiSet = redisTemplate.opsForZSet().range(userKey, 0, -1);

		if (jtiSet != null && !jtiSet.isEmpty()) {
			// 2. 批量删除设备详情
			List<String> deviceKeys = jtiSet.stream()
					.map(RedisKeyConstants::buildDeviceInfoKey)
					.toList();
			redisTemplate.delete(deviceKeys);
		}

		// 3. 删除设备列表
		redisTemplate.delete(userKey);

		log.debug("清空用户所有设备: userId={}", userId);
	}

	/**
	 * 获取用户的在线设备数量
	 */
	public Long getUserDeviceCount(Long userId) {
		String userKey = RedisKeyConstants.buildUserOnlineKey(userId);
		return redisTemplate.opsForZSet().zCard(userKey);
	}

	/**
	 * 获取最早登录的设备（用于顶号逻辑）
	 */
	public String getOldestDevice(Long userId) {
		String userKey = RedisKeyConstants.buildUserOnlineKey(userId);
		Set<String> jtiSet = redisTemplate.opsForZSet().range(userKey, 0, 0);
		return (jtiSet != null && !jtiSet.isEmpty()) ? jtiSet.iterator().next() : null;
	}
}

// ❌ 低效写法（N 次网络请求）
for (String jti : jtiSet) {
    String deviceKey = RedisKeyConstants.buildDeviceInfoKey(jti);
    redisTemplate.delete(deviceKey);
}

// ✅ 高效写法（1 次网络请求）
List<String> deviceKeys = jtiSet.stream()
    .map(RedisKeyConstants::buildDeviceInfoKey)
    .toList()
redisTemplate.delete(deviceKeys);

package com.example.auth.core.service;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.IdUtil;
import com.example.auth.core.config.properties.JwtProperties;
import com.example.auth.core.manager.BlacklistRedisManager;
import com.example.auth.core.manager.TokenRedisManager;
import com.example.auth.core.model.AuthToken;
import com.example.auth.core.model.DeviceInfo;
import com.example.auth.core.util.JwtUtil;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.ExpiredJwtException;
import io.jsonwebtoken.JwtException;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.util.Date;
import java.util.List;

/**
 * 认证服务（Facade 层 / 应用服务层）
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class AuthService {

	private final JwtUtil jwtUtil;
	private final JwtProperties jwtProperties;
	private final TokenRedisManager tokenRedisManager;
	private final BlacklistRedisManager blacklistRedisManager;

	// ==================== 登录相关 ====================

	/**
	 * 登录：创建双令牌（带设备信息）
	 */
	public AuthToken login(Long userId, String username, DeviceInfo deviceInfo) {
		log.info("用户登录: userId={}, username={}, 设备类型={}",
				userId, username, deviceInfo.getDeviceType());

		// 1. 生成 Access Token (JWT) - 纯内存操作
		String accessToken = jwtUtil.createToken(userId, username, null);

		// 2. 从 Access Token 中提取 JTI
		String jti = jwtUtil.getJtiFromToken(accessToken);

		// 3. 补充设备信息中的 JTI 和登录时间
		deviceInfo.setJti(jti);
		deviceInfo.setLoginTime(System.currentTimeMillis() / 1000);

		// 4. 生成 Refresh Token（随机字符串）
		String refreshToken = IdUtil.fastSimpleUUID();

		// 5. 计算 Refresh Token 的过期时间（秒）
		long expireSeconds = jwtProperties.getRefreshTokenExpireDays() * 86400L;

		// 6. 将 Refresh Token 和设备信息存入 Redis
		tokenRedisManager.saveRefreshToken(userId, refreshToken, jti, expireSeconds, deviceInfo);

		log.info("用户登录成功: userId={}, jti={}, IP={}", userId, jti, deviceInfo.getIp());

		// 7. 打包返回
		return AuthToken.builder()
				.accessToken(accessToken)
				.refreshToken(refreshToken)
				.expiresIn((long) jwtProperties.getAccessTokenExpireMinutes() * 60)
				.build();
	}

	// ==================== 令牌刷新 ====================

	/**
	 * 刷新令牌：使用 Refresh Token 换取新的令牌对
	 */
	public AuthToken refresh(String oldRefreshToken, DeviceInfo deviceInfo) {
		log.info("刷新令牌请求");

		// 1. 验证 Refresh Token 并获取用户 ID
		Long userId = tokenRedisManager.getUserIdByRefreshToken(oldRefreshToken);

		if (userId == null) {
			log.warn("Refresh Token 无效或已过期");
			throw new RuntimeException("刷新令牌无效或已过期，请重新登录");
		}

		// 2. 查询用户信息（实际业务中应该从数据库查询）
		String username = "User-" + userId;

		// 3. 令牌轮换 - 生成一对全新的令牌
		AuthToken newTokenPair = login(userId, username, deviceInfo);

		// 4. 立即销毁旧的 Refresh Token（防止重放攻击）
		tokenRedisManager.deleteRefreshToken(oldRefreshToken);

		log.info("令牌刷新成功: userId={}", userId);
		return newTokenPair;
	}

	// ==================== 令牌验证（集成黑名单检查） ====================

	/**
	 * 验证 Token（集成黑名单检查）
	 */
	public Claims validateToken(String token) {
		try {
			// 1. 验证签名和过期时间（本地操作，无网络开销）
			Claims claims = jwtUtil.parseToken(token);

			// 2. 检查是否在黑名单中（Redis 查询，O(1) 复杂度）
			String jti = claims.getId();
			if (blacklistRedisManager.exists(jti)) {
				log.warn("Token 已被注销: jti={}", jti);
				throw new RuntimeException("Token 已被注销，请重新登录");
			}

			return claims;

		} catch (ExpiredJwtException e) {
			log.debug("Token 已过期: {}", e.getMessage());
			throw new RuntimeException("Token 已过期，请重新登录");
		} catch (JwtException e) {
			log.warn("Token 验证失败: {}", e.getMessage());
			throw new RuntimeException("Token 无效");
		}
	}

	/**
	 * 快速验证（只返回布尔值）
	 */
	public boolean isTokenValid(String token) {
		try {
			validateToken(token);
			return true;
		} catch (Exception e) {
			return false;
		}
	}

	// ==================== 注销相关 ====================

	/**
	 * 单设备注销（用户主动退出）
	 */
	public void logout(String accessToken, String refreshToken) {
		log.info("单设备注销请求");

		try {
			// 1. 解析 Token 获取必要信息
			Claims claims = jwtUtil.parseToken(accessToken);
			String jti = claims.getId();
			Date expiration = claims.getExpiration();
			Long userId = Long.parseLong(claims.getSubject());

			// 2. 将 Access Token 加入黑名单
			blacklistRedisManager.add(jti, expiration);

			// 3. 删除 Refresh Token
			tokenRedisManager.deleteRefreshToken(refreshToken);

			// 4. 从用户在线设备列表中移除
			tokenRedisManager.removeUserDevice(userId, jti);

			log.info("单设备注销成功: userId={}, jti={}", userId, jti);

		} catch (Exception e) {
			log.error("单设备注销失败", e);
			throw new RuntimeException("注销失败", e);
		}
	}

	/**
	 * 全设备注销（密码修改、管理员强制下线）
	 */
	public void logoutAll(Long userId) {
		log.info("全设备注销请求: userId={}", userId);

		try {
			// 1. 获取用户的所有在线设备
			List<DeviceInfo> devices = tokenRedisManager.getUserOnlineDevices(userId);

			if (CollUtil.isEmpty(devices)) {
				log.info("用户没有在线设备: userId={}", userId);
				return;
			}

			// 2. 将所有 JTI 加入黑名单
			long maxExpireSeconds = jwtProperties.getAccessTokenExpireMinutes() * 60L;
			devices.forEach(device -> blacklistRedisManager.add(device.getJti(), maxExpireSeconds));

			// 3. 清空用户的在线设备列表
			tokenRedisManager.clearUserDevices(userId);

			log.info("全设备注销成功: userId={}, 设备数量={}", userId, devices.size());

		} catch (Exception e) {
			log.error("全设备注销失败: userId={}", userId, e);
			throw new RuntimeException("全设备注销失败", e);
		}
	}

	/**
	 * 踢出指定设备（远程注销）
	 */
	public void kickoutDevice(Long userId, String jti) {
		log.info("踢出设备请求: userId={}, jti={}", userId, jti);

		try {
			// 1. 将 JTI 加入黑名单
			long maxExpireSeconds = jwtProperties.getAccessTokenExpireMinutes() * 60L;
			blacklistRedisManager.add(jti, maxExpireSeconds);

			// 2. 从用户在线设备列表中移除
			tokenRedisManager.removeUserDevice(userId, jti);

			log.info("踢出设备成功: userId={}, jti={}", userId, jti);

		} catch (Exception e) {
			log.error("踢出设备失败: userId={}, jti={}", userId, jti, e);
			throw new RuntimeException("踢出设备失败", e);
		}
	}

	// ==================== 设备管理 ====================

	/**
	 * 查询用户的在线设备列表
	 */
	public List<DeviceInfo> getOnlineDevices(Long userId) {
		log.info("查询在线设备: userId={}", userId);
		return tokenRedisManager.getUserOnlineDevices(userId);
	}

	/**
	 * 获取设备详情
	 */
	public DeviceInfo getDeviceInfo(String jti) {
		return tokenRedisManager.getDeviceInfo(jti);
	}

	// ==================== 辅助方法 ====================

	/**
	 * 从 Token 中提取用户 ID
	 */
	public Long getUserIdFromToken(String token) {
		Claims claims = validateToken(token);
		return Long.parseLong(claims.getSubject());
	}
}

package com.example.auth.web.controller;

import com.example.auth.common.model.Result;
import com.example.auth.core.model.AuthToken;
import com.example.auth.core.model.DeviceInfo;
import com.example.auth.core.service.AuthService;
import com.example.auth.core.util.DeviceInfoExtractor;
import io.jsonwebtoken.Claims;
import jakarta.servlet.http.HttpServletRequest;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 认证控制器
 */
@Slf4j
@RestController
@RequestMapping("/auth")
@RequiredArgsConstructor
public class AuthController {

	private final AuthService authService;

	/**
	 * 双令牌登录接口（带设备信息）
	 */
	@PostMapping("/login")
	public Result<AuthToken> login(@RequestParam Long userId,
	                               @RequestParam String username,
	                               HttpServletRequest request) {
		log.info("收到登录请求: userId={}, username={}", userId, username);

		// 提取设备信息
		DeviceInfo deviceInfo = buildDeviceInfo(request);

		AuthToken authToken = authService.login(userId, username, deviceInfo);
		return Result.ok(authToken);
	}

	/**
	 * 刷新令牌接口（带设备信息）
	 */
	@PostMapping("/refresh")
	public Result<AuthToken> refresh(@RequestParam String refreshToken,
	                                 HttpServletRequest request) {
		log.info("收到刷新令牌请求");
		try {
			// 提取设备信息
			DeviceInfo deviceInfo = buildDeviceInfo(request);

			AuthToken authToken = authService.refresh(refreshToken, deviceInfo);
			return Result.ok(authToken);
		} catch (Exception e) {
			log.error("刷新令牌失败", e);
			return Result.fail(401, e.getMessage());
		}
	}

	/**
	 * 单设备注销接口
	 */
	@PostMapping("/logout")
	public Result<Void> logout(@RequestHeader("Authorization") String authHeader,
	                           @RequestParam String refreshToken) {
		log.info("收到注销请求");
		try {
			String accessToken = extractToken(authHeader);
			authService.logout(accessToken, refreshToken);
			return Result.ok();
		} catch (Exception e) {
			log.error("注销失败", e);
			return Result.fail(500, "注销失败：" + e.getMessage());
		}
	}

	/**
	 * 全设备注销接口
	 */
	@PostMapping("/logout/all")
	public Result<Void> logoutAll(@RequestHeader("Authorization") String authHeader) {
		log.info("收到全设备注销请求");
		try {
			String accessToken = extractToken(authHeader);
			Long userId = authService.getUserIdFromToken(accessToken);
			authService.logoutAll(userId);
			return Result.ok();
		} catch (Exception e) {
			log.error("全设备注销失败", e);
			return Result.fail(500, "全设备注销失败：" + e.getMessage());
		}
	}

	/**
	 * 验证令牌接口
	 */
	@GetMapping("/validate")
	public Result<Map<String, Object>> validate(@RequestHeader("Authorization") String authHeader) {
		log.info("收到验证令牌请求");
		try {
			String token = extractToken(authHeader);
			Claims claims = authService.validateToken(token);

			Map<String, Object> data = new HashMap<>();
			data.put("valid", true);
			data.put("userId", claims.getSubject());
			data.put("username", claims.get("username"));

			return Result.ok(data);
		} catch (Exception e) {
			log.debug("Token 验证失败: {}", e.getMessage());
			Map<String, Object> data = new HashMap<>();
			data.put("valid", false);
			data.put("reason", e.getMessage());
			return Result.ok(data);
		}
	}

	// ==================== 设备管理接口 ====================

	/**
	 * 查询在线设备列表
	 */
	@GetMapping("/devices")
	public Result<List<DeviceInfo>> getDevices(@RequestHeader("Authorization") String authHeader) {
		log.info("收到查询在线设备请求");
		try {
			String accessToken = extractToken(authHeader);
			Long userId = authService.getUserIdFromToken(accessToken);
			List<DeviceInfo> devices = authService.getOnlineDevices(userId);
			return Result.ok(devices);
		} catch (Exception e) {
			log.error("查询在线设备失败", e);
			return Result.fail(500, "查询失败：" + e.getMessage());
		}
	}

	/**
	 * 踢出指定设备
	 */
	@DeleteMapping("/devices/{jti}")
	public Result<Void> kickoutDevice(@RequestHeader("Authorization") String authHeader,
	                                  @PathVariable String jti) {
		log.info("收到踢出设备请求: jti={}", jti);
		try {
			String accessToken = extractToken(authHeader);
			Long userId = authService.getUserIdFromToken(accessToken);
			authService.kickoutDevice(userId, jti);
			return Result.ok();
		} catch (Exception e) {
			log.error("踢出设备失败: jti={}", jti, e);
			return Result.fail(500, "踢出设备失败：" + e.getMessage());
		}
	}

	// ==================== 辅助方法 ====================

	/**
	 * 从 Authorization Header 中提取 Token
	 */
	private String extractToken(String authHeader) {
		if (authHeader != null && authHeader.startsWith("Bearer ")) {
			return authHeader.substring(7);
		}
		return authHeader;
	}

	/**
	 * 构建设备信息
	 */
	private DeviceInfo buildDeviceInfo(HttpServletRequest request) {
		return DeviceInfo.builder()
				.deviceType(DeviceInfoExtractor.extractDeviceType(request))
				.os(DeviceInfoExtractor.extractOs(request))
				.browser(DeviceInfoExtractor.extractBrowser(request))
				.ip(DeviceInfoExtractor.extractIp(request))
				.build();
	}
}

package com.example.auth.core.config.properties;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Data
@Component
@ConfigurationProperties(prefix = "jwt")
public class JwtProperties {

	/**
	 * 签发者标识 (Issuer)
	 */
	private String issuer = "auth-service";

	/**
	 * Access Token 有效期（分钟）
	 */
	private Integer accessTokenExpireMinutes = 15;

	/**
	 * Refresh Token 有效期（天）
	 */
	private Integer refreshTokenExpireDays = 7;

	/**
	 * 时钟偏差容忍度（秒）
	 */
	private Long clockSkewSeconds = 30L;

	/**
	 * 公钥资源路径
	 */
	private String publicKeyResource = "certs/public_key.pem";

	/**
	 * 私钥资源路径
	 */
	private String privateKeyResource = "certs/private_key.pem";

	/**
	 * 最大在线设备数（0 表示不限制）
	 */
	private Integer maxDevices = 0;
}

/**
 * 登录：创建双令牌（带设备信息 + 设备数量限制）
 */
public AuthToken login(Long userId, String username, DeviceInfo deviceInfo) {
	log.info("用户登录: userId={}, username={}, 设备类型={}",
			userId, username, deviceInfo.getDeviceType());

	// ========== 新增：设备数量限制检查 ==========
	Integer maxDevices = jwtProperties.getMaxDevices();
	if (maxDevices != null && maxDevices > 0) {
		Long currentDeviceCount = tokenRedisManager.getUserDeviceCount(userId);

		if (currentDeviceCount >= maxDevices) {
			// 达到设备数量上限，踢出最早登录的设备
			String oldestJti = tokenRedisManager.getOldestDevice(userId);
			if (oldestJti != null) {
				log.info("设备数量达到上限，踢出最早登录的设备: userId={}, jti={}", userId, oldestJti);
				kickoutDevice(userId, oldestJti);
			}
		}
	}
	// ========== 设备数量限制检查结束 ==========

	// 1. 生成 Access Token (JWT) - 纯内存操作
	String accessToken = jwtUtil.createToken(userId, username, null);

	// ... 后续逻辑保持不变
}