/*
具体实现理论参见 mongodb官方  objectid生成策略
http://docs.mongodb.org/manual/reference/object-id/
ObjectId 是一个由12字节组成的bson数据，按照字节顺序，一次代表：
ObjectId is a 12-byte BSON type, constructed using:
4个字节代表1970年元月一日到现在毫秒数  UNIX时间戳
a 4-byte value representing the seconds since the Unix epoch,
3个字节代表机器的唯一标识符    表示运行的机器
a 3-byte machine identifier,
2个字节代表进程的id 表示生成此_id的进程
a 2-byte process id, and
3个字节代表计数器，开始带着一个随机数   由一个随机数开始的计数器生成的值
a 3-byte counter, starting with a random value.

*/

package objectid

import (
    "crypto/md5"
    "encoding/hex"
    "fmt"
    "math/rand"
    "os"
    "sync/atomic"
    "time"
)

var staticMachine = getMachineHash()  //获取机器的id
var staticIncrement = getRandomNumber()//获取随机数
var staticPid = int32(os.Getpid())//获取进程id
//
type ObjectId struct {
    timestamp int64
    machine   int32
    pid       int32
    increment int32
}
//
func New() *ObjectId {
    timestamp := time.Now().Unix()
    return &ObjectId{timestamp, staticMachine, staticPid, atomic.AddInt32(&staticIncrement, 1) & 0xffffff}
}
//
func Parse(input string) *ObjectId {
    if len(input) == 0 {
        panic("The input is empty.")
    }
    if value, ok := tryParse(input); ok {
        return value
    }
    panic(fmt.Sprintf("%s is not a valid 24 digit hex string.", input))
}
//
func (this *ObjectId) Timestamp() int64 {
    return this.timestamp
}
//
func (this *ObjectId) Machine() int32 {
    return this.machine
}
//
func (this *ObjectId) Pid() int32 {
    return this.pid
}
//
func (this *ObjectId) Increment() int32 {
    return this.increment & 0xffffff
}
//
func (this *ObjectId) CreationTime() time.Time {
    return time.Unix(this.timestamp, 0)
}
//
func (this *ObjectId) Equal(other *ObjectId) bool {
    return this.timestamp == other.timestamp &&
        this.machine == other.machine &&
        this.pid == other.pid &&
        this.increment == other.increment
}
//
func (this *ObjectId) String() string {
    array := []byte{
        byte(this.timestamp >> 0x18),
        byte(this.timestamp >> 0x10),
        byte(this.timestamp >> 8),
        byte(this.timestamp),
        byte(this.machine >> 0x10),
        byte(this.machine >> 8),
        byte(this.machine),
        byte(this.pid >> 8),
        byte(this.pid),
        byte(this.increment >> 0x10),
        byte(this.increment >> 8),
        byte(this.increment),
    }
    return hex.EncodeToString(array)
}
//获取机器唯一标识符
func getMachineHash() int32 {
    machineName, err := os.Hostname()
    if err != nil {
        panic(err)
    }
    buf := md5.Sum([]byte(machineName))
    return (int32(buf[0])<<0x10 + int32(buf[1])<<8) + int32(buf[2])
}
//获取随机数开始的计数器生成的值
func getRandomNumber() int32 {
    rand.Seed(time.Now().UnixNano())
    return rand.Int31()
}
//从字符串objectid  解析成为ObjectId
func tryParse(input string) (*ObjectId, bool) {
    if len(input) != 0x18 {
        return nil, false
    }
    array, err := hex.DecodeString(input) //十六进制的字符串 转化为字节切片 
    if err != nil {
        return nil, false
    }
    return &ObjectId{
        timestamp: int64(array[0])<<0x18 + int64(array[1])<<0x10 + int64(array[2])<<8 + int64(array[3]),
               //转化为十进制的int64  新纪元时间  毫秒
        machine:   int32(array[4])<<0x10 + int32(array[5])<<8 + int32(array[6]),
               //转化为十进制的int32数据   机器唯一标识符
        pid:       int32(array[7])<<8 + int32(array[8]),
              // 当前进程id
        increment: int32(array[9])<<0x10 + (int32(array[10]) << 8) + int32(array[11]),
              // 随机数开始的计数器生成的值
    }, true
}