public class PiSnowflakeIdGenerator implements IdGenerator {

    /**
     * Number of bits used for the sequence number.
     */
    private static final long SEQUENCE_BITS = 10L;

    /**
     * Number of bits used for the worker ID.
     */
    private static final long WORKER_ID_BITS = 7L;

    /**
     * Number of bits used for the data center ID.
     */
    private static final long DATA_CENTER_BITS = 3L;

    private static final long SEQUENCE_MASK = (1 << SEQUENCE_BITS) - 1;

    private static final long WORKER_ID_LEFT_SHIFT_BITS = SEQUENCE_BITS;
    private static final long DATACENTER_LEFT_SHIFT_BITS = SEQUENCE_BITS + WORKER_ID_BITS;
    private static final long TIMESTAMP_LEFT_SHIFT_BITS = WORKER_ID_LEFT_SHIFT_BITS + WORKER_ID_BITS + DATA_CENTER_BITS;

    /**
     * Worker ID (7 bits)
     */
    private long workId = 1;

    /**
     * Data center ID (3 bits)
     */
    private long dataCenter = 1;

    /**
     * Last timestamp recorded
     */
    private long lastTime;

    /**
     * Sequence number
     */
    private long sequence;

    private byte sequenceOffset;

    public PiSnowflakeIdGenerator() {
        try {
            String ip = IpUtil.getLocalIp4Address();
            String[] cells = StringUtils.split(ip, ".");
            this.dataCenter = Integer.parseInt(cells[0]) & ((1 << DATA_CENTER_BITS) - 1);
            this.workId = Integer.parseInt(cells[3]) >> 16 & ((1 << WORKER_ID_BITS) - 1);
        } catch (Exception e) {
            this.dataCenter = 1;
            this.workId = 1;
        }
    }

    public PiSnowflakeIdGenerator(int workId, int dataCenter) {
        this.workId = workId;
        this.dataCenter = dataCenter;
    }

    /**
     * Generate a trend-incrementing ID.
     *
     * @return Unique ID
     */
    @Override
    public synchronized Long nextId() {
        long nowTime = waitToIncrDiffIfNeed(getNowTime());
        if (lastTime == nowTime) {
            if (0L == (sequence = (sequence + 1) & SEQUENCE_MASK)) {
                // Sequence number used up in the current time unit; wait for the next second.
                nowTime = waitUntilNextTime(nowTime);
            }
        } else {
            // Alternate the starting sequence value between 0 and 1
            vibrateSequenceOffset();
            sequence = sequenceOffset;
        }
        lastTime = nowTime;

        long ans = ((nowTime % DateUtil.ONE_DAY_SECONDS) << TIMESTAMP_LEFT_SHIFT_BITS)
                 | (dataCenter << DATACENTER_LEFT_SHIFT_BITS)
                 | (workId << WORKER_ID_LEFT_SHIFT_BITS)
                 | sequence;

        if (log.isDebugEnabled()) {
            log.debug("seconds:{}, datacenter:{}, work:{}, seq:{}, ans={}",
                    nowTime % DateUtil.ONE_DAY_SECONDS, dataCenter, workId, sequence, ans);
        }

        return Long.parseLong(String.format("%s%011d", getDaySegment(nowTime), ans));
    }

    /**
     * If the current time is earlier than the last recorded time, wait until the clock catches up to avoid duplicates.
     *
     * @param nowTime Current timestamp
     * @return Adjusted timestamp
     */
    private long waitToIncrDiffIfNeed(final long nowTime) {
        if (lastTime <= nowTime) {
            return nowTime;
        }
        long diff = lastTime - nowTime;
        AsyncUtil.sleep(diff);
        return getNowTime();
    }

    /**
     * Wait until the next time unit (second).
     *
     * @param lastTime Previous timestamp
     * @return Next timestamp
     */
    private long waitUntilNextTime(final long lastTime) {
        long result = getNowTime();
        while (result <= lastTime) {
            result = getNowTime();
        }
        return result;
    }

    /**
     * Toggle the sequence offset between 0 and 1 to avoid fixed starting sequence.
     */
    private void vibrateSequenceOffset() {
        sequenceOffset = (byte) (~sequenceOffset & 1);
    }

    /**
     * Get the current time in seconds.
     *
     * @return Current time in seconds
     */
    private long getNowTime() {
        return System.currentTimeMillis() / 1000;
    }

    /**
     * Build a date-based prefix using year and day-of-year format.
     *
     * @param time Timestamp
     * @return Date segment prefix
     */
    private static String getDaySegment(long time) {
        LocalDateTime localDate = DateUtil.time2LocalTime(time * 1000L);
        return String.format("%02d%03d", localDate.getYear() % 100, localDate.getDayOfYear());
    }
}