plum

module std
import std/Number
import std/Result
import std/Str
import std/Bool

# A UUID, stored as its canonical 36-character
# `xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx` text form.
enum Uuid(ToStr) =
  | Uuid(value: Str)

  fun toStr(self) -> Str =
    return self.value

  fun equals(self, other: Uuid) -> Bool =
    return self.value == other.value

  fun isNil(self) -> Bool =
    return self.value == NIL

  # The version nibble (1-5 for a well-formed RFC 4122 UUID), the first hex
  # digit of the third group (`xxxxxxxx-xxxx-Vxxx-...`), at string index 14.
  fun version(self) -> Int =
    return hexValue(self.value.byteAt(14))

  # The variant bits, decoded from the high bits of the first hex digit of
  # the fourth group (`...-Nxxx-...`), at string index 19. Returns 0 for the
  # NCS-backward-compatible variant (`0xxx`), 2 for the RFC 4122 variant
  # (`10xx`, what `v4` produces), 6 for Microsoft's (`110x`), 7 for the
  # reserved future variant (`111x`).
  fun variant(self) -> Int =
    n := hexValue(self.value.byteAt(19))
    if n & 0x8 == 0
      return 0
    if n & 0x4 == 0
      return 2
    if n & 0x2 == 0
      return 6
    return 7

NIL = "00000000-0000-0000-0000-000000000000"

fun nil() -> Uuid =
  return Uuid(value: NIL)

# Parses the canonical `xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx` text form
# (case-insensitive), returning `Err` if `s` isn't exactly that shape.
fun fromStr(s: Str) -> Result[Uuid, Str] =
  if s.length() != 36
    return Err("invalid UUID length: '{s}'")
  i := 0
  while i < 36
    if i == 8 || i == 13 || i == 18 || i == 23
      # '-'
      if s.byteAt(i) != 45
        return Err("invalid UUID: '{s}'")
    else
      if hexValue(s.byteAt(i)) < 0
        return Err("invalid UUID: '{s}'")
    i = i + 1
  return Ok(Uuid(value: s.toLower()))

fun isValid(s: Str) -> Bool =
  match fromStr(s)
    Ok(_) => True
    Err(_) => False

# The numeric value (0-15) of an ASCII hex digit byte, or -1 if it isn't one.
fun hexValue(byte: Int) -> Int =
  # '0'-'9'
  if byte >= 48 && byte <= 57
    return byte - 48
  # 'a'-'f'
  if byte >= 97 && byte <= 102
    return byte - 97 + 10
  # 'A'-'F'
  if byte >= 65 && byte <= 70
    return byte - 65 + 10
  return -1

# A random (version 4, RFC 4122) UUID.
fun v4() -> Uuid =
  a := rawRandomInt()
  b := rawRandomInt()
  time_low := { a >> 32 } & 0xFFFFFFFF
  time_mid := { a >> 16 } & 0xFFFF
  time_hi_and_version := { a & 0x0FFF } | 0x4000
  clock_seq := { { b >> 48 } & 0x3FFF } | 0x8000
  node := b & 0xFFFFFFFFFFFF
  s := hexDigits(time_low, 8) + "-" + hexDigits(time_mid, 4) + "-"
    + hexDigits(time_hi_and_version, 4) + "-" + hexDigits(clock_seq, 4) + "-"
    + hexDigits(node, 12)
  return Uuid(value: s)

fun hexDigit(n: Int) -> Str =
  d := n & 0xF
  if d < 10
    return digitChar(d)
  match d
    10 => "a"
    11 => "b"
    12 => "c"
    13 => "d"
    14 => "e"
    _ => "f"

# The low `count` hex digits of `n`, most-significant first.
fun hexDigits(n: Int, count: Int) -> Str =
  if count <= 0
    return ""
  return hexDigits(n >> 4, count - 1) + hexDigit(n)

test "nil is the all-zero UUID and is recognized as such"
  assert nil().toStr() == "00000000-0000-0000-0000-000000000000"
  assert nil().isNil() == True

test "v4 produces a valid version-4, variant-2 UUID"
  u := v4()
  assert isValid(u.toStr()) == True
  assert u.version() == 4
  assert u.variant() == 2
  assert u.isNil() == False

test "fromStr parses a valid UUID and normalizes case"
  match fromStr("550E8400-E29B-41D4-A716-446655440000")
    Ok(u) =>
      assert u.toStr() == "550e8400-e29b-41d4-a716-446655440000"
    Err(_) =>
      assert True == False

test "fromStr rejects malformed input"
  assert isValid("not-a-uuid") == False
  assert isValid("550e8400-e29b-41d4-a716-44665544000") == False
  assert isValid("550e8400xe29b-41d4-a716-446655440000") == False

test "equals compares by value"
  a := Uuid(value: "550e8400-e29b-41d4-a716-446655440000")
  b := Uuid(value: "550e8400-e29b-41d4-a716-446655440000")
  assert a.equals(b) == True
  assert a.equals(nil()) == False