// Copyright 2018 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"

	"errors"

	"fmt"

	"io"

	"strings"

)

// A UUID is a 128 bit (16 byte) Universal Unique IDentifier as defined in RFC

// 4122.

type UUID [16]byte

// A Version represents a UUID's version.

type Version byte

// A Variant represents a UUID's variant.

type Variant byte

// Constants returned by Variant.

const (

	Invalid   = Variant(iota) // Invalid UUID

	RFC4122                   // The variant specified in RFC4122

	Reserved                  // Reserved, NCS backward compatibility.

	Microsoft                 // Reserved, Microsoft Corporation backward compatibility.

	Future                    // Reserved for future definition.

)

var rander = rand.Reader // random function

// Parse decodes s into a UUID or returns an error.  Both the standard UUID

// forms of xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx and

// urn:uuid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx are decoded as well as the

// Microsoft encoding {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx} and the raw hex

// encoding: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.

func Parse(s string) (UUID, error) {

	var uuid UUID

	switch len(s) {

	// xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx

	case 36:

	// urn:uuid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx

	case 36 + 9:

		if strings.ToLower(s[:9]) != "urn:uuid:" {

			return uuid, fmt.Errorf("invalid urn prefix: %q", s[:9])

		}

		s = s[9:]

	// {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}

	case 36 + 2:

		s = s[1:]

	// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

	case 32:

		var ok bool

		for i := range uuid {

			uuid[i], ok = xtob(s[i*2], s[i*2+1])

			if !ok {

				return uuid, errors.New("invalid UUID format")

			}

		}

		return uuid, nil

	default:

		return uuid, fmt.Errorf("invalid UUID length: %d", len(s))

	}

	// s is now at least 36 bytes long

	// it must be of the form  xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx

	if s[8] != '-' || s[13] != '-' || s[18] != '-' || s[23] != '-' {

		return uuid, errors.New("invalid UUID format")

	}

	for i, x := range [16]int{

		0, 2, 4, 6,

		9, 11,

		14, 16,

		19, 21,

		24, 26, 28, 30, 32, 34} {

		v, ok := xtob(s[x], s[x+1])

		if !ok {

			return uuid, errors.New("invalid UUID format")

		}

		uuid[i] = v

	}

	return uuid, nil

}

// ParseBytes is like Parse, except it parses a byte slice instead of a string.

func ParseBytes(b []byte) (UUID, error) {

	var uuid UUID

	switch len(b) {

	case 36: // xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx

	case 36 + 9: // urn:uuid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx

		if !bytes.Equal(bytes.ToLower(b[:9]), []byte("urn:uuid:")) {

			return uuid, fmt.Errorf("invalid urn prefix: %q", b[:9])

		}

		b = b[9:]

	case 36 + 2: // {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}

		b = b[1:]

	case 32: // xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

		var ok bool

		for i := 0; i < 32; i += 2 {

			uuid[i/2], ok = xtob(b[i], b[i+1])

			if !ok {

				return uuid, errors.New("invalid UUID format")

			}

		}

		return uuid, nil

	default:

		return uuid, fmt.Errorf("invalid UUID length: %d", len(b))

	}

	// s is now at least 36 bytes long

	// it must be of the form  xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx

	if b[8] != '-' || b[13] != '-' || b[18] != '-' || b[23] != '-' {

		return uuid, errors.New("invalid UUID format")

	}

	for i, x := range [16]int{

		0, 2, 4, 6,

		9, 11,

		14, 16,

		19, 21,

		24, 26, 28, 30, 32, 34} {

		v, ok := xtob(b[x], b[x+1])

		if !ok {

			return uuid, errors.New("invalid UUID format")

		}

		uuid[i] = v

	}

	return uuid, nil

}

// MustParse is like Parse but panics if the string cannot be parsed.

// It simplifies safe initialization of global variables holding compiled UUIDs.

func MustParse(s string) UUID {

	uuid, err := Parse(s)

	if err != nil {

		panic(`uuid: Parse(` + s + `): ` + err.Error())

	}

	return uuid

}

// FromBytes creates a new UUID from a byte slice. Returns an error if the slice

// does not have a length of 16. The bytes are copied from the slice.

func FromBytes(b []byte) (uuid UUID, err error) {

	err = uuid.UnmarshalBinary(b)

	return uuid, err

}

// Must returns uuid if err is nil and panics otherwise.

func Must(uuid UUID, err error) UUID {

	if err != nil {

		panic(err)

	}

	return uuid

}

// String returns the string form of uuid, xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx

// , or "" if uuid is invalid.

func (uuid UUID) String() string {

	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 {

	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.

func (uuid UUID) Variant() Variant {

	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.

func (uuid UUID) Version() Version {

	return Version(uuid[6] >> 4)

}

func (v Version) String() string {

	if v > 15 {

		return fmt.Sprintf("BAD_VERSION_%d", v)

	}

	return fmt.Sprintf("VERSION_%d", v)

}

func (v Variant) String() string {

	switch v {

	case RFC4122:

		return "RFC4122"

	case Reserved:

		return "Reserved"

	case Microsoft:

		return "Microsoft"

	case Future:

		return "Future"

	case Invalid:

		return "Invalid"

	}

	return fmt.Sprintf("BadVariant%d", int(v))

}

// 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) {

	if r == nil {

		rander = rand.Reader

		return

	}

	rander = r

}