// Copyright 2011 Google Inc.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package uuid

import (
        "encoding/binary"
        "fmt"
        "os"
)

// A Domain represents a Version 2 domain
type Domain byte

// Domain constants for DCE Security (Version 2) UUIDs.
const (
        Person = Domain(0)
        Group  = Domain(1)
        Org    = Domain(2)
)

// NewDCESecurity returns a DCE Security (Version 2) UUID.
//
// The domain should be one of Person, Group or Org.
// On a POSIX system the id should be the users UID for the Person
// domain and the users GID for the Group.  The meaning of id for
// the domain Org or on non-POSIX systems is site defined.
//
// For a given domain/id pair the same token may be returned for up to
// 7 minutes and 10 seconds.
func NewDCESecurity(domain Domain, id uint32) UUID {
        uuid := NewUUID()
        if uuid != nil {
                uuid[6] = (uuid[6] & 0x0f) | 0x20 // Version 2
                uuid[9] = byte(domain)
                binary.BigEndian.PutUint32(uuid[0:], id)
        }
        return uuid
}

// NewDCEPerson returns a DCE Security (Version 2) UUID in the person
// domain with the id returned by os.Getuid.
//
//  NewDCEPerson(Person, uint32(os.Getuid()))
func NewDCEPerson() UUID {
        return NewDCESecurity(Person, uint32(os.Getuid()))
}

// NewDCEGroup returns a DCE Security (Version 2) UUID in the group
// domain with the id returned by os.Getgid.
//
//  NewDCEGroup(Group, uint32(os.Getgid()))
func NewDCEGroup() UUID {
        return NewDCESecurity(Group, uint32(os.Getgid()))
}

// Domain returns the domain for a Version 2 UUID or false.
func (uuid UUID) Domain() (Domain, bool) {
        if v, _ := uuid.Version(); v != 2 {
                return 0, false
        }
        return Domain(uuid[9]), true
}

// Id returns the id for a Version 2 UUID or false.
func (uuid UUID) Id() (uint32, bool) {
        if v, _ := uuid.Version(); v != 2 {
                return 0, false
        }
        return binary.BigEndian.Uint32(uuid[0:4]), true
}

func (d Domain) String() string {
        switch d {
        case Person:
                return "Person"
        case Group:
                return "Group"
        case Org:
                return "Org"
        }
        return fmt.Sprintf("Domain%d", int(d))
}

// Copyright 2011 Google Inc.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package uuid

import (
        "crypto/md5"
        "crypto/sha1"
        "hash"
)

// Well known Name Space IDs and UUIDs
var (
        NameSpace_DNS  = Parse("6ba7b810-9dad-11d1-80b4-00c04fd430c8")
        NameSpace_URL  = Parse("6ba7b811-9dad-11d1-80b4-00c04fd430c8")
        NameSpace_OID  = Parse("6ba7b812-9dad-11d1-80b4-00c04fd430c8")
        NameSpace_X500 = Parse("6ba7b814-9dad-11d1-80b4-00c04fd430c8")
        NIL            = Parse("00000000-0000-0000-0000-000000000000")
)

// NewHash returns a new UUID derived from the hash of space concatenated with
// data generated by h.  The hash should be at least 16 byte in length.  The
// first 16 bytes of the hash are used to form the UUID.  The version of the
// UUID will be the lower 4 bits of version.  NewHash is used to implement
// NewMD5 and NewSHA1.
func NewHash(h hash.Hash, space UUID, data []byte, version int) UUID {
        h.Reset()
        h.Write(space)
        h.Write([]byte(data))
        s := h.Sum(nil)
        uuid := make([]byte, 16)
        copy(uuid, s)
        uuid[6] = (uuid[6] & 0x0f) | uint8((version&0xf)<<4)
        uuid[8] = (uuid[8] & 0x3f) | 0x80 // RFC 4122 variant
        return uuid
}

// NewMD5 returns a new MD5 (Version 3) UUID based on the
// supplied name space and data.
//
//  NewHash(md5.New(), space, data, 3)
func NewMD5(space UUID, data []byte) UUID {
        return NewHash(md5.New(), space, data, 3)
}

// NewSHA1 returns a new SHA1 (Version 5) UUID based on the
// supplied name space and data.
//
//  NewHash(sha1.New(), space, data, 5)
func NewSHA1(space UUID, data []byte) UUID {
        return NewHash(sha1.New(), space, data, 5)
}

// Copyright 2016 Google Inc.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package uuid

import (
        "errors"
        "fmt"

        guuid "github.com/google/uuid"
)

// MarshalText implements encoding.TextMarshaler.
func (u UUID) MarshalText() ([]byte, error) {
        if len(u) != 16 {
                return nil, nil
        }
        var js [36]byte
        encodeHex(js[:], u)
        return js[:], nil
}

// UnmarshalText implements encoding.TextUnmarshaler.
func (u *UUID) UnmarshalText(data []byte) error {
        if len(data) == 0 {
                return nil
        }
        id := Parse(string(data))
        if id == nil {
                return errors.New("invalid UUID")
        }
        *u = id
        return nil
}

// MarshalBinary implements encoding.BinaryMarshaler.
func (u UUID) MarshalBinary() ([]byte, error) {
        return u[:], nil
}

// UnmarshalBinary implements encoding.BinaryUnmarshaler.
func (u *UUID) UnmarshalBinary(data []byte) error {
        if len(data) == 0 {
                return nil
        }
        if len(data) != 16 {
                return fmt.Errorf("invalid UUID (got %d bytes)", len(data))
        }
        var id [16]byte
        copy(id[:], data)
        *u = id[:]
        return nil
}

// MarshalText implements encoding.TextMarshaler.
func (u Array) MarshalText() ([]byte, error) {
        var js [36]byte
        encodeHex(js[:], u[:])
        return js[:], nil
}

// UnmarshalText implements encoding.TextUnmarshaler.
func (u *Array) UnmarshalText(data []byte) error {
        id, err := guuid.ParseBytes(data)
        if err != nil {
                return err
        }
        *u = Array(id)
        return nil
}

// MarshalBinary implements encoding.BinaryMarshaler.
func (u Array) MarshalBinary() ([]byte, error) {
        return u[:], nil
}

// UnmarshalBinary implements encoding.BinaryUnmarshaler.
func (u *Array) UnmarshalBinary(data []byte) error {
        if len(data) != 16 {
                return fmt.Errorf("invalid UUID (got %d bytes)", len(data))
        }
        copy(u[:], data)
        return nil
}

// Copyright 2011 Google Inc.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package uuid

import (
        guuid "github.com/google/uuid"
)

// NodeInterface returns the name of the interface from which the NodeID was
// derived.  The interface "user" is returned if the NodeID was set by
// SetNodeID.
func NodeInterface() string {
        return guuid.NodeInterface()
}

// SetNodeInterface selects the hardware address to be used for Version 1 UUIDs.
// If name is "" then the first usable interface found will be used or a random
// Node ID will be generated.  If a named interface cannot be found then false
// is returned.
//
// SetNodeInterface never fails when name is "".
func SetNodeInterface(name string) bool {
        return guuid.SetNodeInterface(name)
}

// NodeID returns a slice of a copy of the current Node ID, setting the Node ID
// if not already set.
func NodeID() []byte {
        return guuid.NodeID()
}

// SetNodeID sets the Node ID to be used for Version 1 UUIDs.  The first 6 bytes
// of id are used.  If id is less than 6 bytes then false is returned and the
// Node ID is not set.
func SetNodeID(id []byte) bool {
        return guuid.SetNodeID(id)
}

// NodeID returns the 6 byte node id encoded in uuid.  It returns nil if uuid is
// not valid.  The NodeID is only well defined for version 1 and 2 UUIDs.
func (uuid UUID) NodeID() []byte {
        if len(uuid) != 16 {
                return nil
        }
        node := make([]byte, 6)
        copy(node, uuid[10:])
        return node
}

// Copyright 2015 Google Inc.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package uuid

import (
        "database/sql/driver"
        "errors"
        "fmt"
)

// Scan implements sql.Scanner so UUIDs can be read from databases transparently
// Currently, database types that map to string and []byte are supported. Please
// consult database-specific driver documentation for matching types.
func (uuid *UUID) Scan(src interface{}) error {
        switch src.(type) {
        case string:
                // if an empty UUID comes from a table, we return a null UUID
                if src.(string) == "" {
                        return nil
                }

                // see uuid.Parse for required string format
                parsed := Parse(src.(string))

                if parsed == nil {
                        return errors.New("Scan: invalid UUID format")
                }

                *uuid = parsed
        case []byte:
                b := src.([]byte)

                // if an empty UUID comes from a table, we return a null UUID
                if len(b) == 0 {
                        return nil
                }

                // assumes a simple slice of bytes if 16 bytes
                // otherwise attempts to parse
                if len(b) == 16 {
                        parsed := make([]byte, 16)
                        copy(parsed, b)
                        *uuid = UUID(parsed)
                } else {
                        u := Parse(string(b))

                        if u == nil {
                                return errors.New("Scan: invalid UUID format")
                        }

                        *uuid = u
                }

        default:
                return fmt.Errorf("Scan: unable to scan type %T into UUID", src)
        }

        return nil
}

// Value implements sql.Valuer so that UUIDs can be written to databases
// transparently. Currently, UUIDs map to strings. Please consult
// database-specific driver documentation for matching types.
func (uuid UUID) Value() (driver.Value, error) {
        return uuid.String(), nil
}

// Copyright 2014 Google Inc.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package uuid

import (
        "encoding/binary"

        guuid "github.com/google/uuid"
)

// A Time represents a time as the number of 100's of nanoseconds since 15 Oct
// 1582.
type Time = guuid.Time

// GetTime returns the current Time (100s of nanoseconds since 15 Oct 1582) and
// clock sequence as well as adjusting the clock sequence as needed.  An error
// is returned if the current time cannot be determined.
func GetTime() (Time, uint16, error) { return guuid.GetTime() }

// ClockSequence returns the current clock sequence, generating one if not
// already set.  The clock sequence is only used for Version 1 UUIDs.
//
// The uuid package does not use global static storage for the clock sequence or
// the last time a UUID was generated.  Unless SetClockSequence a new random
// clock sequence is generated the first time a clock sequence is requested by
// ClockSequence, GetTime, or NewUUID.  (section 4.2.1.1) sequence is generated
// for
func ClockSequence() int { return guuid.ClockSequence() }

// SetClockSequence sets the clock sequence to the lower 14 bits of seq.  Setting to
// -1 causes a new sequence to be generated.
func SetClockSequence(seq int) { guuid.SetClockSequence(seq) }

// Time returns the time in 100s of nanoseconds since 15 Oct 1582 encoded in
// uuid.  It returns false if uuid is not valid.  The time is only well defined
// for version 1 and 2 UUIDs.
func (uuid UUID) Time() (Time, bool) {
        if len(uuid) != 16 {
                return 0, false
        }
        time := int64(binary.BigEndian.Uint32(uuid[0:4]))
        time |= int64(binary.BigEndian.Uint16(uuid[4:6])) << 32
        time |= int64(binary.BigEndian.Uint16(uuid[6:8])&0xfff) << 48
        return Time(time), true
}

// ClockSequence returns the clock sequence encoded in uuid.  It returns false
// if uuid is not valid.  The clock sequence is only well defined for version 1
// and 2 UUIDs.
func (uuid UUID) ClockSequence() (int, bool) {
        if len(uuid) != 16 {
                return 0, false
        }
        return int(binary.BigEndian.Uint16(uuid[8:10])) & 0x3fff, true
}

// Copyright 2011 Google Inc.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package uuid

// xvalues returns the value of a byte as a hexadecimal digit or 255.
var xvalues = [256]byte{
        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 255, 255, 255, 255, 255, 255,
        255, 10, 11, 12, 13, 14, 15, 255, 255, 255, 255, 255, 255, 255, 255, 255,
        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
        255, 10, 11, 12, 13, 14, 15, 255, 255, 255, 255, 255, 255, 255, 255, 255,
        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
}

// xtob converts the the first two hex bytes of x into a byte.
func xtob(x string) (byte, bool) {
        b1 := xvalues[x[0]]
        b2 := xvalues[x[1]]
        return (b1 << 4) | b2, b1 != 255 && b2 != 255
}

// Copyright 2011 Google Inc.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package uuid

import (
        "bytes"
        "crypto/rand"
        "encoding/hex"
        "io"

        guuid "github.com/google/uuid"
)

// Array is a pass-by-value UUID that can be used as an effecient key in a map.
type Array [16]byte

// UUID converts uuid into a slice.
func (uuid Array) UUID() UUID {
        return uuid[:]
}

// String returns the string representation of uuid,
// xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.
func (uuid Array) String() string {
        return guuid.UUID(uuid).String()
}

// A UUID is a 128 bit (16 byte) Universal Unique IDentifier as defined in RFC
// 4122.
type UUID []byte

// A Version represents a UUIDs version.
type Version = guuid.Version

// A Variant represents a UUIDs variant.
type Variant = guuid.Variant

// Constants returned by Variant.
const (
        Invalid   = guuid.Invalid   // Invalid UUID
        RFC4122   = guuid.RFC4122   // The variant specified in RFC4122
        Reserved  = guuid.Reserved  // Reserved, NCS backward compatibility.
        Microsoft = guuid.Microsoft // Reserved, Microsoft Corporation backward compatibility.
        Future    = guuid.Future    // Reserved for future definition.
)

var rander = rand.Reader // random function

// New returns a new random (version 4) UUID as a string.  It is a convenience
// function for NewRandom().String().
func New() string {
        return NewRandom().String()
}

// Parse decodes s into a UUID or returns nil. See github.com/google/uuid for
// the formats parsed.
func Parse(s string) UUID {
        gu, err := guuid.Parse(s)
        if err == nil {
                return gu[:]
        }
        return nil
}

// ParseBytes is like Parse, except it parses a byte slice instead of a string.
func ParseBytes(b []byte) (UUID, error) {
        gu, err := guuid.ParseBytes(b)
        if err == nil {
                return gu[:], nil
        }
        return nil, err
}

// Equal returns true if uuid1 and uuid2 are equal.
func Equal(uuid1, uuid2 UUID) bool {
        return bytes.Equal(uuid1, uuid2)
}

// Array returns an array representation of uuid that can be used as a map key.
// Array panics if uuid is not valid.
func (uuid UUID) Array() Array {
        if len(uuid) != 16 {
                panic("invalid uuid")
        }
        var a Array
        copy(a[:], uuid)
        return a
}

// String returns the string form of uuid, xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
// , or "" if uuid is invalid.
func (uuid UUID) String() string {
        if len(uuid) != 16 {
                return ""
        }
        var buf [36]byte
        encodeHex(buf[:], uuid)
        return string(buf[:])
}

// URN returns the RFC 2141 URN form of uuid,
// urn:uuid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx,  or "" if uuid is invalid.
func (uuid UUID) URN() string {
        if len(uuid) != 16 {
                return ""
        }
        var buf [36 + 9]byte
        copy(buf[:], "urn:uuid:")
        encodeHex(buf[9:], uuid)
        return string(buf[:])
}

func encodeHex(dst []byte, uuid UUID) {
        hex.Encode(dst[:], uuid[:4])
        dst[8] = '-'
        hex.Encode(dst[9:13], uuid[4:6])
        dst[13] = '-'
        hex.Encode(dst[14:18], uuid[6:8])
        dst[18] = '-'
        hex.Encode(dst[19:23], uuid[8:10])
        dst[23] = '-'
        hex.Encode(dst[24:], uuid[10:])
}

// Variant returns the variant encoded in uuid.  It returns Invalid if
// uuid is invalid.
func (uuid UUID) Variant() Variant {
        if len(uuid) != 16 {
                return Invalid
        }
        switch {
        case (uuid[8] & 0xc0) == 0x80:
                return RFC4122
        case (uuid[8] & 0xe0) == 0xc0:
                return Microsoft
        case (uuid[8] & 0xe0) == 0xe0:
                return Future
        default:
                return Reserved
        }
}

// Version returns the version of uuid.  It returns false if uuid is not
// valid.
func (uuid UUID) Version() (Version, bool) {
        if len(uuid) != 16 {
                return 0, false
        }
        return Version(uuid[6] >> 4), true
}

// SetRand sets the random number generator to r, which implements io.Reader.
// If r.Read returns an error when the package requests random data then
// a panic will be issued.
//
// Calling SetRand with nil sets the random number generator to the default
// generator.
func SetRand(r io.Reader) {
        guuid.SetRand(r)
}

// Copyright 2011 Google Inc.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package uuid

import (
        guuid "github.com/google/uuid"
)

// NewUUID returns a Version 1 UUID based on the current NodeID and clock
// sequence, and the current time.  If the NodeID has not been set by SetNodeID
// or SetNodeInterface then it will be set automatically.  If the NodeID cannot
// be set NewUUID returns nil.  If clock sequence has not been set by
// SetClockSequence then it will be set automatically.  If GetTime fails to
// return the current NewUUID returns nil.
func NewUUID() UUID {
        gu, err := guuid.NewUUID()
        if err == nil {
                return UUID(gu[:])
        }
        return nil
}

// Copyright 2011 Google Inc.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package uuid

import guuid "github.com/google/uuid"

// NewRandom returns a Random (Version 4) UUID or panics.
//
// The strength of the UUIDs is based on the strength of the crypto/rand
// package.
//
// A note about uniqueness derived from the UUID Wikipedia entry:
//
//  Randomly generated UUIDs have 122 random bits.  One's annual risk of being
//  hit by a meteorite is estimated to be one chance in 17 billion, that
//  means the probability is about 0.00000000006 (6 × 10−11),
//  equivalent to the odds of creating a few tens of trillions of UUIDs in a
//  year and having one duplicate.
func NewRandom() UUID {
        if gu, err := guuid.NewRandom(); err == nil {
                return UUID(gu[:])
        }
        return nil
}