//實現(xiàn)方法：
package main


import (
	"errors"
	"fmt"
	"sync"
	"time"
)

/*
	雪花算法(snowFlake)的具體實現(xiàn)方案:
 */

type SnowFlake struct{
	mu sync.Mutex
	//雪花算法開啟時的起始時間戳
	twepoch int64

	//每一部分占用的位數(shù)
	workerIdBits     int64 //每個數(shù)據(jù)中心的工作機器的編號位數(shù)
	datacenterIdBits int64 //數(shù)據(jù)中心的編號位數(shù)
	sequenceBits     int64 //每個工作機器每毫秒遞增的位數(shù)

	//每一部分最大的數(shù)值
	maxWorkerId int64
	maxDatacenterId int64
	maxSequence int64

	//每一部分向左移動的位數(shù)
	workerIdShift int64
	datacenterIdShift int64
	timestampShift int64

	//當前數(shù)據(jù)中心ID號
	datacenterId int64
	//當前機器的ID號
	workerId int64
	//序列號
	sequence int64
	//上一次生成ID號前41位的毫秒時間戳
	lastTimestamp int64
}

/*
	獲取毫秒的時間戳
 */
func (s *SnowFlake)timeGen()int64{
	return time.Now().UnixMilli()
}
/*
	獲取比lastTimestamp大的當前毫秒時間戳
 */
func (s *SnowFlake)tilNextMills()int64{
	timeStampMill:=s.timeGen()
	for timeStampMill<=s.lastTimestamp{
		timeStampMill=s.timeGen()
	}
	return timeStampMill
}
func (s *SnowFlake)NextId()(int64,error){
	s.mu.Lock()
	defer s.mu.Unlock()
	nowTimestamp:=s.timeGen()//獲取當前的毫秒級別的時間戳
	if nowTimestamp<s.lastTimestamp{
		//系統(tǒng)時鐘倒退,倒退了s.lastTimestamp-nowTimestamp
		return -1,errors.New(fmt.Sprintf("clock moved backwards, Refusing to generate id for %d milliseconds",s.lastTimestamp-nowTimestamp))
	}
	if nowTimestamp==s.lastTimestamp{
		s.sequence=(s.sequence+1)&s.maxSequence
		if s.sequence==0{
			 //tilNextMills中有一個循環(huán)等候當前毫秒時間戳到達lastTimestamp的下一個毫秒時間戳
			nowTimestamp=s.tilNextMills()
		}
	}else{
		s.sequence=0
	}
	s.lastTimestamp=nowTimestamp
	return (nowTimestamp-s.twepoch)<<s.timestampShift| //時間戳差值部分
		s.datacenterId<<s.datacenterIdShift| //數(shù)據(jù)中心部分
		s.workerId<<s.workerIdShift| //工作機器編號部分
		s.sequence, //序列號部分
		nil
}

func NewSnowFlake(workerId int64,datacenterId int64)(*SnowFlake,error){
	mySnow:=new(SnowFlake)
	mySnow.twepoch=time.Now().Unix() //返回當前時間的時間戳(時間戳是指北京時間1970年01月01日8時0分0秒到此時時刻的總秒數(shù))
	if workerId<0||datacenterId<0{
		return nil,errors.New("workerId or datacenterId must not lower than 0 ")
	}
	/*
		標準的雪花算法
	 */
	mySnow.workerIdBits =5
	mySnow.datacenterIdBits=5
	mySnow.sequenceBits=12

	mySnow.maxWorkerId=-1^(-1<<mySnow.workerIdBits)         //64位末尾workerIdBits位均設為1,其余設為0
	mySnow.maxDatacenterId=-1^(-1<<mySnow.datacenterIdBits) //64位末尾datacenterIdBits位均設為1,其余設為0
	mySnow.maxSequence=-1^(-1<<mySnow.sequenceBits)  //64位末尾sequenceBits位均設為1,其余設為0

	if workerId>=mySnow.maxWorkerId||datacenterId>=mySnow.maxDatacenterId{
		return nil,errors.New("workerId or datacenterId must not higher than max value ")
	}
	mySnow.workerIdShift=mySnow.sequenceBits
	mySnow.datacenterIdShift=mySnow.sequenceBits+mySnow.workerIdBits
	mySnow.timestampShift=mySnow.sequenceBits+mySnow.workerIdBits+mySnow.datacenterIdBits

	mySnow.lastTimestamp=-1
	mySnow.workerId=workerId
	mySnow.datacenterId=datacenterId

	return mySnow,nil
}



func main(){
	//模擬實驗是生成并發(fā)400W個ID,所需要的時間
	mySnow,_:=NewSnowFlake(0,0)//生成雪花算法
	group:=sync.WaitGroup{}
	startTime:=time.Now()
	generateId:=func (s SnowFlake,requestNumber int){
		for i:=0;i<requestNumber;i++{
			s.NextId()
			group.Done()
		}
	}
	group.Add(4000000)
	//生成并發(fā)的數(shù)為4000000
	currentThreadNum:=400
	for i:=0;i<currentThreadNum;i++{
		generateId(*mySnow,10000)
	}
	group.Wait()
	fmt.Printf("time: %v\n",time.Now().Sub(startTime))
}