package com.zyq.util;
 
import lombok.Data;
 
import java.util.*;
import java.util.concurrent.ConcurrentLinkedDeque;
 
/**
 * 緩存工具類
 * <p>
 * 【說明】
 * 寫這個工具類的背景是因?yàn)轫撁嬗械臅r候需要攜帶參數(shù)從A頁面跳轉(zhuǎn)到B頁面，如果參數(shù)長度過大，
 * 就會導(dǎo)致url拼接過長，而url的長度是有限的。因此前端可以先請求后端，后端將數(shù)據(jù)保存在某處，
 * 然后返回一個uuid給前端，前端攜帶該uuid跳轉(zhuǎn)到B頁面，再通過該uuid拿到數(shù)據(jù)，
 * 這樣就可以解決頁面跳轉(zhuǎn)參數(shù)過長丟失數(shù)據(jù)的問題。
 * <p>
 * 該工具類適用單節(jié)點(diǎn)部署的項(xiàng)目，或者多節(jié)點(diǎn)部署時路由規(guī)則是按用戶進(jìn)行路由的（寫這個工具類也是先了解了該項(xiàng)目是單體部署的）。
 * 如果是多節(jié)點(diǎn)項(xiàng)目部署，且后端路由規(guī)則不是根據(jù)用戶的話，那么該工具類就不適用。
 * 比如第一次請求獲取的是后端1節(jié)點(diǎn)生成的uuid，但是再次訪問的時候把uuid攜帶到了后端2節(jié)點(diǎn)，因此是獲取不到的。
 * （可以將對應(yīng)的數(shù)據(jù)緩存到Redis或數(shù)據(jù)庫的方式進(jìn)行存?。?
 *
 * @author zyqok
 * @since 2023/7/20
 */
public class UserCacheUtils {
 
    /**
     * 清理過期數(shù)據(jù)最小周期時間（單位：毫秒），當(dāng)前為1分鐘
     */
    private static final long MIN_CLEAR_MILLISECONDS = 6000;
 
    /**
     * 緩存最小時間（單位：秒），當(dāng)前為1秒
     */
    private static final long MIN_CACHE_SECONDS = 1;
 
    /**
     * 緩存最大時間（單位：秒），當(dāng)前為1天
     */
    private static final long MAX_CACHE_SECONDS = 24 * 60 * 60;
 
    /**
     * 上一次清理過期數(shù)據(jù)的時間
     */
    private static long lastClearExpireTime = System.currentTimeMillis();
 
    /**
     * 緩存的數(shù)據(jù)
     */
    private static ConcurrentLinkedDeque<UserData> caches;
 
 
    /**
     * 清理過期數(shù)據(jù)
     */
    private static synchronized void clearExpire() {
        final long currentTime = System.currentTimeMillis();
        final long diffTime = currentTime - lastClearExpireTime;
        if (diffTime > MIN_CLEAR_MILLISECONDS && Objects.nonNull(caches)) {
            lastClearExpireTime = currentTime;
            caches.removeIf(o -> o.getExpireTime() <= currentTime);
        }
    }
 
    /**
     * 去獲取過期時間
     *
     * @param seconds 緩存的時間（單位秒），區(qū)間為[1秒，24小時]
     */
    private static long getExpireTime(long seconds) {
        if (seconds < MIN_CACHE_SECONDS) {
            seconds = MIN_CACHE_SECONDS;
        }
        if (seconds > MAX_CACHE_SECONDS) {
            seconds = MAX_CACHE_SECONDS;
        }
        return System.currentTimeMillis() + seconds * 1000;
    }
 
    /**
     * 緩存數(shù)據(jù)
     *
     * @param userId 用戶ID
     * @param val    緩存的數(shù)據(jù)（數(shù)據(jù)不能為null）
     * @return uuid 唯一性id
     */
    public static String put(int userId, Object val) {
        return put(userId, val, 60L);
    }
 
    /**
     * 緩存數(shù)據(jù)
     *
     * @param userId  用戶ID
     * @param val     數(shù)據(jù)
     * @param seconds 秒
     * @return uuid 唯一性id
     */
    public static String put(int userId, Object val, long seconds) {
        clearExpire();
        if (Objects.isNull(val)) {
            return "";
        }
        String uuid = UUID.randomUUID().toString().replace("-", "");
        UserData data = new UserData();
        data.setUuid(uuid);
        data.setUserId(userId);
        data.setExpireTime(getExpireTime(seconds));
        data.setData(val);
        if (Objects.isNull(caches)) {
            caches = new ConcurrentLinkedDeque<>();
        }
        caches.add(data);
        return uuid;
    }
 
    /**
     * 獲取緩存數(shù)據(jù)
     *
     * @param uuid uuid
     * @return 緩存的數(shù)據(jù)
     */
    public static Object get(int userId, String uuid) {
        clearExpire();
        if (Objects.isNull(uuid) || uuid.trim().isEmpty() || Objects.isNull(caches)) {
            return null;
        }
        for (UserData data : caches) {
            if (data.getUuid().equals(uuid) && data.getUserId() == userId) {
                return data.getData();
            }
        }
        return null;
    }
 
 
    @Data
    static class UserData {
        private String uuid;
        private int userId;
        private long expireTime;
        private Object data;
    }
 
 
}