/**
 * @Author liqiang
 * @Description 网关测试
 * @Date 2025/03/26/14:32
 */
@RestController
@RequestMapping("/c/gateway/testGateway")
public class TestGateWayQueryApi {

    @PostMapping("/1.0/testGateway")
    @ApiOperation(value = "测试gateway", notes = "测试gateway")
    public ResponseBase<String> testGateway(Long sleep) {
        if (Objects.nonNull(sleep) && sleep > 0) {
            try {
                Thread.sleep(sleep);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        return ResponseBase.success(String.valueOf(System.currentTimeMillis()));
    }


}

  if (!stringRedisTemplate.opsForSet().isMember(Const.EFFECTIVE_LOGIN_USER_ID, user.getUserId())) {
            return getVoidMono(serverWebExchange, new TokenForbiddenResponse("User Token Forbidden or Expired!"));
        }

    private Mono<TokenContext> validateUser(TokenContext tokenContext) {
        JWTInfo jwtInfo = tokenContext.getJwtInfo();
        StopWatch stopWatch = null;
        if (log.isDebugEnabled()) {
            stopWatch = new StopWatch();
            stopWatch.start("EFFECTIVE_LOGIN_USER_ID");
        }
        StopWatch finalStopWatch = stopWatch;
        return reactiveRedisTemplate.opsForSet()
            .isMember(Const.EFFECTIVE_LOGIN_USER_ID, jwtInfo.getUserId())
            .flatMap(isMember -> {
                if (log.isDebugEnabled()) {
                    finalStopWatch.stop();
                    log.debug("ReactorAccessFilter EFFECTIVE_LOGIN_USER_ID ={}",
                        finalStopWatch.getLastTaskTimeMillis());
                }
                if (!isMember) {
                    // 返回错误信号，由上层统一处理
                    return Mono.error(
                        new YxtRuntimeException(ResponseCodeType.BIZ_EXCEPTION, "User Token Forbidden or Expired!"));
                }
                return Mono.just(tokenContext);
            });
    }

public class UserAuthUtil {
    public UserAuthUtil(KeyConfiguration keyConfiguration){
        this.keyConfiguration=keyConfiguration;
    }

    private KeyConfiguration keyConfiguration;

    public JWTInfo getInfoFromToken(String token) throws Exception {
        try {
            return JWTHelper.getInfoFromToken(token, keyConfiguration.getUserPubKey());
        }catch (ExpiredJwtException ex){
            throw new UserTokenException("User token expired!");
        }catch (SignatureException ex){
            throw new UserTokenException("User token signature error!");
        }catch (IllegalArgumentException ex){
            throw new UserTokenException("User token is null or empty!");
        }
    }
}

    // 解析 JWT 并缓存到 Redis
    private Mono<JWTInfo> parseAndCacheJwt(String token) {
        return Mono.fromCallable(() -> userAuthUtil.getInfoFromToken(token))  // 阻塞操作封装
            .subscribeOn(Schedulers.boundedElastic()); // 切换到弹性线程池
    }

/**
 * @Author liqiang
 * @Description ReactorNetty
 * @Date 2025/03/27/16:48
 */
@Configuration
public class ReactorNettyConfig {

    /**
     * @return
     * @See reactor.netty.tcp.TcpResources#create
     */
    @Bean
    public ReactorResourceFactory reactorClientResourceFactory() {
        /**
         * 定义 Netty 的Selector 线程数，负责监听网络事件（如连接建立、数据到达）
         * 默认值：-1（由 Netty 自动分配，通常为 CPU 核心数）。
         * 若为 CPU 密集型应用，设置为 1 可减少上下文切换；若为高并发 I/O 密集型应用，保留默认值或按需调整。
         */
        System.setProperty("reactor.netty.ioSelectCount", "1");
        /**
         * 定义 Netty 的I/O 工作线程数，负责处理网络读写、编解码等任务。
         * ：通常设置为 CPU 核心数 * 2（需与容器 CPU 资源限制对齐）。
         */
        System.setProperty("reactor.netty.ioWorkerCount",
            String.valueOf(Runtime.getRuntime().availableProcessors() * 2));
        return new ReactorResourceFactory();
    }
}