public class SnowflakeIdGenerator {
    // 起始時間戳，這里以2025-07-01 00:00:00為基準
    private final long startTimeStamp = 1751299200000L;
    
    // 機器ID所占位數
    private final long workerIdBits = 5L;
    // 數據中心ID所占位數
    private final long dataCenterIdBits = 5L;
    // 序列號所占位數
    private final long sequenceBits = 12L;
    
    // 機器ID最大值 31
    private final long maxWorkerId = -1L ^ (-1L << workerIdBits);
    // 數據中心ID最大值 31
    private final long maxDataCenterId = -1L ^ (-1L << dataCenterIdBits);
    
    // 機器ID向左移位數
    private final long workerIdShift = sequenceBits;
    // 數據中心ID向左移位數
    private final long dataCenterIdShift = sequenceBits + workerIdBits;
    // 時間戳向左移位數
    private final long timestampShift = sequenceBits + workerIdBits + dataCenterIdBits;
    
    // 序列號掩碼 4095
    private final long sequenceMask = -1L ^ (-1L << sequenceBits);
    
    // 工作機器ID
    private final long workerId;
    // 數據中心ID
    private final long dataCenterId;
    // 序列號
    private long sequence = 0L;
    // 上次生成ID的時間戳
    private long lastTimestamp = -1L;
    
    // 構造函數
    public SnowflakeIdGenerator(long workerId, long dataCenterId) {
        if (workerId > maxWorkerId || workerId < 0) {
            throw new IllegalArgumentException("Worker ID 不能大于 " + maxWorkerId + " 或小于 0");
        }
        if (dataCenterId > maxDataCenterId || dataCenterId < 0) {
            throw new IllegalArgumentException("數據中心 ID 不能大于 " + maxDataCenterId + " 或小于 0");
        }
        this.workerId = workerId;
        this.dataCenterId = dataCenterId;
    }
    
    // 生成下一個ID
    public synchronized long nextId() {
        long currentTimestamp = System.currentTimeMillis();
        
        if (currentTimestamp == lastTimestamp) {
            sequence = (sequence + 1) & sequenceMask;
            if (sequence == 0) {
                // 當前毫秒內序列號已用完，等待下一毫秒
                currentTimestamp = waitNextMillis(lastTimestamp);
            }
        } else {
            // 時間戳改變，重置序列號
            sequence = 0L;
        }
        
        lastTimestamp = currentTimestamp;
        
        // 按規(guī)則組合生成ID
        return ((currentTimestamp - startTimeStamp) << timestampShift) |
                (dataCenterId << dataCenterIdShift) |
                (workerId << workerIdShift) |
                sequence;
    }
    
    // 等待下一毫秒
    private long waitNextMillis(long lastTimestamp) {
        long timestamp = System.currentTimeMillis();
        while (timestamp <= lastTimestamp) {
            timestamp = System.currentTimeMillis();
        }
        return timestamp;
    }
    
    // 測試示例
    public static void main(String[] args) {
        SnowflakeIdGenerator idGenerator = new SnowflakeIdGenerator(1, 1);
        for (int i = 0; i < 10; i++) {
            System.out.println(idGenerator.nextId());
        }
    }
}    

// 獲取機器ID
private static long getNodeId() {
    try {
        InetAddress address = findFirstNonLoopbackAddress();
        String ip = address.getHostAddress();
        int hash = ip.hashCode();
        // 確保非負數并取模最大節(jié)點ID
        long nodeId = (hash & 0x7FFFFFFF) % (MAX_NODE_ID + 1);
        System.out.println("使用IP地址: " + ip + " 生成機器ID: " + nodeId);
        return nodeId;
    } catch (Exception e) {
        // 異常時隨機生成節(jié)點ID
        long nodeId = new Random().nextInt((int) (MAX_NODE_ID + 1));
        System.out.println("獲取IP失敗，隨機生成機器ID: " + nodeId);
        return nodeId;
    }
}
 
// 查找第一個非環(huán)回IPv4地址
private static InetAddress findFirstNonLoopbackAddress() throws SocketException {
    Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
    while (interfaces.hasMoreElements()) {
        NetworkInterface iface = interfaces.nextElement();
        if (iface.isLoopback() || iface.isVirtual() || !iface.isUp()) {
            continue;
        }
        Enumeration<InetAddress> addresses = iface.getInetAddresses();
        while (addresses.hasMoreElements()) {
            InetAddress addr = addresses.nextElement();
            if (addr instanceof Inet4Address && !addr.isLoopbackAddress()) {
                return addr;
            }
        }
    }
    throw new RuntimeException("未找到非環(huán)回IPv4地址");
}

//處理時鐘回撥
if (currentTimestamp < lastTimestamp) {
    throw new ClockBackwardException(
        "Clock moved backwards. Refusing to generate id for " + 
        (lastTimestamp - currentTimestamp) + " milliseconds");
}

// 處理時鐘回撥
if (currentTimestamp < lastTimestamp) {
    long offset = lastTimestamp - currentTimestamp;
    // 回撥時間小于1秒，阻塞等待
    if (offset <= MAX_BACKWARD_TIME) {
        currentTimestamp = waitForClockRecovery(lastTimestamp);
    } else {
        // 回撥時間超過1秒，拋出異常
        throw new RuntimeException("Clock moved backwards too much: " + offset + "ms");
    }
}
 
private long waitForClockRecovery(long lastTimestamp) {
    long timestamp = System.currentTimeMillis();
    while (timestamp < lastTimestamp) {
        //短暫休眠避免CPU空轉
        try {
            Thread.sleep(1);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException("Interrupted while waiting for clock recovery", e);
        }
        timestamp = System.currentTimeMillis();
    }
    System.out.println("Clock recovered after " + (timestamp - lastTimestamp) + "ms");
    return timestamp;
}

// 可容忍的最大時鐘回撥（毫秒）
private static final long MAX_BACKWARD_MS = 1000;
 
// 發(fā)生時鐘回撥
if (currentTimestamp < lastTimestamp) {
    long backwardMs = lastTimestamp - currentTimestamp;
 
    // 超過容忍閾值則拋出異常
    if (backwardMs > MAX_BACKWARD_MS) {
        throw new IllegalStateException("Clock moved backwards by " + backwardMs + " ms, exceeding maximum allowed value");
    }
    // 記錄回撥時間用于補償
    clockOffset += backwardMs;
    // 補償當前時間戳
    currentTimestamp = System.currentTimeMillis()+clockOffset;
}