package cn.hollis.nft.turbo.auth.controller;

import cn.dev33.satoken.stp.StpUtil;
import cn.hollis.nft.turbo.auth.exception.AuthErrorCode;
import cn.hollis.nft.turbo.auth.exception.AuthException;
import cn.hollis.nft.turbo.web.vo.Result;
import jakarta.validation.constraints.NotBlank;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.UUID;
import java.util.concurrent.TimeUnit;

import static cn.hollis.nft.turbo.cache.constant.CacheConstant.CACHE_KEY_SEPARATOR;

/**
 * TokenController 類負責處理與 token 相關的請求，
 * 主要功能是在用戶登錄狀態(tài)下生成并發(fā)放一個基于 UUID 的 token，
 * 并將其存儲到 Redis 中。
 *
 * @author hollis
 */
@Slf4j
@RequiredArgsConstructor
@RestController
@RequestMapping("token")
public class TokenController {

    /**
     * 定義 token 鍵的前綴，用于在 Redis 中存儲 token 時標識鍵。
     */
    private static final String TOKEN_PREFIX = "token:";

    /**
     * 注入 Spring Data Redis 提供的 StringRedisTemplate，
     * 用于操作 Redis 中的字符串類型數據。
     */
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    /**
     * 該接口用于在用戶登錄狀態(tài)下，根據傳入的場景信息生成一個唯一的 token，
     * 并將其存儲到 Redis 中，設置 30 分鐘的過期時間。
     *
     * @param scene 生成 token 的場景信息，不能為空。
     * @return 封裝了生成的 token 鍵的統(tǒng)一響應對象 Result。
     * @throws AuthException 若用戶未登錄，拋出用戶未登錄的認證異常。
     */
    @GetMapping("/get")
    public Result<String> get(@NotBlank String scene) {
        // 檢查用戶是否已登錄
        if (StpUtil.isLogin()) {
            // 生成一個基于 UUID 的唯一 token
            String token = UUID.randomUUID().toString();
            // 拼接用于存儲到 Redis 的 token 鍵
            String tokenKey = TOKEN_PREFIX + scene + CACHE_KEY_SEPARATOR + token;
            // 將 token 存儲到 Redis 中，設置 30 分鐘的過期時間
            stringRedisTemplate.opsForValue().set(tokenKey, token, 30, TimeUnit.MINUTES);
            // 返回包含 token 鍵的成功響應
            return Result.success(tokenKey);
        }
        // 若用戶未登錄，拋出用戶未登錄的認證異常
        throw new AuthException(AuthErrorCode.USER_NOT_LOGIN);
    }
}

package jakarta.servlet;

import java.io.IOException;

public interface Filter {
    // 過濾器初始化方法，在過濾器實例創(chuàng)建后調用，用于初始化資源
    public default void init(FilterConfig filterConfig) throws ServletException {}

    // 過濾方法，每次請求經過該過濾器時都會調用，用于實現(xiàn)具體的過濾邏輯
    public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException;

    // 過濾器銷毀方法，在過濾器實例銷毀前調用，用于釋放資源
    public default void destroy() {}
}

package cn.hollis.nft.turbo.web.filter;

import jakarta.servlet.*;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.apache.commons.lang3.BooleanUtils;
import org.redisson.api.RScript;
import org.redisson.api.RedissonClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.util.Arrays;
import java.util.UUID;

/**
 * @author Hollis
 */
public class TokenFilter implements Filter {

    private static final Logger logger = LoggerFactory.getLogger(TokenFilter.class);

    public static final ThreadLocal<String> tokenThreadLocal = new ThreadLocal<>();

    public static final ThreadLocal<Boolean> stressThreadLocal = new ThreadLocal<>();

    private RedissonClient redissonClient;

    // 選擇構造器注入bean的方式 是spring官方推薦的注入方式
    public TokenFilter(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;
    }

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // 過濾器初始化，可選實現(xiàn)
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        try {
            HttpServletRequest httpRequest = (HttpServletRequest) request;
            HttpServletResponse httpResponse = (HttpServletResponse) response;
            // 從請求頭中獲取Token
            String token = httpRequest.getHeader("Authorization");
            // 原來的邏輯是從redis里獲取并且驗證token
            // 如果是壓測環(huán)境 那么直接生成一個UUID作為Token
            Boolean isStress = BooleanUtils.toBoolean(httpRequest.getHeader("isStress"));

            if (token == null || "null".equals(token) || "undefined".equals(token)) {
                httpResponse.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                httpResponse.getWriter().write("No Token Found ...");
                logger.error("no token found in header , pls check!");
                return;
            }
            // 校驗Token的有效性
            boolean isValid = checkTokenValidity(token, isStress);
            // Token無效
            if (!isValid) {
                httpResponse.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                httpResponse.getWriter().write("Invalid or expired token");
                logger.error("token validate failed , pls check!");
                return;
            }
            // Token有效，繼續(xù)執(zhí)行其他過濾器鏈
            chain.doFilter(request, response);
        } finally {
            // ThreadLocal 可能會存在內存泄漏的問題
            tokenThreadLocal.remove();
            stressThreadLocal.remove();
        }
    }

    private boolean checkTokenValidity(String token, Boolean isStress) {
        // 獲取指定鍵的值
        // 刪除這個鍵
        // 返回獲取到的數值
        String luaScript = """
                local value = redis.call('GET', KEYS[1])
                redis.call('DEL', KEYS[1])
                return value""";
        // 6.2.3以上可以直接使用GETDEL命令
        // String value = (String) redisTemplate.opsForValue().getAndDelete(token);
        String result = (String) redissonClient.getScript().eval(RScript.Mode.READ_WRITE,
                luaScript,
                RScript.ReturnType.STATUS,
                Arrays.asList(token));
        if (isStress) {
            //如果是壓測，則生成一個隨機數，模擬 token
            result = UUID.randomUUID().toString();
            stressThreadLocal.set(isStress);
        }
        tokenThreadLocal.set(result);
        return result != null;

    }

    @Override
    public void destroy() {
        // 過濾器銷毀，可選實現(xiàn)
    }
}

package cn.hollis.nft.turbo.web.configuration;

import cn.hollis.nft.turbo.web.filter.TokenFilter;
import cn.hollis.nft.turbo.web.handler.GlobalWebExceptionHandler;
import org.redisson.api.RedissonClient;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * @author Hollis
 * 這是所有mvc入口的一個配置 實現(xiàn)了 WebMvcConfigurer接口
 * AutoConfiguration注解 標記此類為自動配置類
 * ConditionalOnWebApplication 條件注釋 表示在web環(huán)境下 配置類生效
 * 注冊了一系列過濾器
 */
@AutoConfiguration
@ConditionalOnWebApplication
public class WebConfiguration implements WebMvcConfigurer {

    @Bean
    @ConditionalOnMissingBean
    GlobalWebExceptionHandler globalWebExceptionHandler() {
        return new GlobalWebExceptionHandler();
    }

    /**
     * 注冊token過濾器
     *
     * @param redissonClient
     * @return
     */
    @Bean
    public FilterRegistrationBean<TokenFilter> tokenFilter(RedissonClient redissonClient) {
        FilterRegistrationBean<TokenFilter> registrationBean = new FilterRegistrationBean<>();
        // 設置要注冊的過濾器為 TokenFilter 實例，并傳入 RedissonClient 對象。
        registrationBean.setFilter(new TokenFilter(redissonClient));
        // 設置過濾器需要攔截的 URL 路徑，只有請求路徑匹配這些模式時，TokenFilter 才會處理該請求。
        registrationBean.addUrlPatterns("/trade/buy","/trade/newBuy","/trade/normalBuy");
        // 設置過濾器的執(zhí)行順序，數字越小，執(zhí)行優(yōu)先級越高。
        registrationBean.setOrder(10);

        return registrationBean;
    }

}