# SPDX-FileCopyrightText: 2021 ☭ Emery Hemingway
# SPDX-License-Identifier: ISC

import bigints
import std/[base64, endians, hashes, options, sets, streams, strutils, tables, typetraits]

from std/json import escapeJson, escapeJsonUnquoted
from std/macros import hasCustomPragma, getCustomPragmaVal

type
  PreserveKind* = enum
    pkBoolean, pkFloat, pkDouble, pkSignedInteger, pkBigInteger, pkString,
        pkByteString, pkSymbol, pkRecord, pkSequence, pkSet, pkDictionary, pkEmbedded

  Preserve* {.acyclic.} = object
    ## Type that stores a Preserves value.
    case kind*: PreserveKind
    of pkBoolean:
      bool*: bool
    of pkFloat:
      float*: float32
    of pkDouble:
      double*: float64
    of pkSignedInteger:
      int*: BiggestInt
    of pkBigInteger:
      bigint*: BigInt
    of pkString:
      string*: string
    of pkByteString:
      bytes*: seq[byte]
    of pkSymbol:
      symbol*: string
    of pkRecord:
      record*: seq[Preserve] # label is last
    of pkSequence:
      sequence*: seq[Preserve]
    of pkSet:
      set*: HashSet[Preserve]
    of pkDictionary:
      dict*: Table[Preserve, Preserve]
    of pkEmbedded:
      embedded*: pointer

proc assertValid*(prs: Preserve) =
  case prs.kind
  of pkBigInteger:
    assert(BiggestInt.low.initBigInt < prs.bigint and prs.bigint < BiggestInt.high.initBigInt)
  of pkRecord:
    assert(prs.record.len > 0, "invalid Preserves record " & prs.repr)
    assert(prs.record[prs.record.high].kind < pkRecord)
    for v in prs.record: assertValid(v)
  of pkSequence:
    for v in prs.sequence: assertValid(v)
  of pkSet:
    for v in prs.set: assertValid(v)
  of pkDictionary:
    for key, val in prs.dict.pairs:
      # assert(key.kind < pkRecord)
      assertValid(key)
      assertValid(val)
  else:
    discard

proc isNil*(prs: Preserve): bool =
  ## Check if ``prs`` is equivalent to the zero-initialized ``Preserve``.
  prs.kind == pkBoolean and prs.bool == false

proc `<`(x, y: string | seq[byte]): bool =
  for i in 0 .. min(x.high, y.high):
    if x[i] < y[i]:
      return true
  x.len < y.len

proc `<`*(x, y: Preserve): bool =
  if x.kind != y.kind:
    if x.kind == pkSignedInteger and y.kind == pkBigInteger:
      result = x.int.initBigInt < y.bigint
    elif x.kind == pkBigInteger and y.kind == pkSignedInteger:
      result = x.bigint < y.int.initBigInt
    else:
      result = x.kind < y.kind
  else:
    case x.kind
    of pkBoolean:
      result = (not x.bool) and y.bool
    of pkSignedInteger:
      result = x.int < y.int
    of pkBigInteger:
      result = x.bigint < y.bigint
    of pkString:
      result = x.string < y.string
    of pkByteString:
      result = x.bytes < y.bytes
    of pkSymbol:
      result = x.symbol < y.symbol
    else:
      discard

proc hash*(prs: Preserve): Hash =
  var h = hash(prs.kind.int)
  case prs.kind
  of pkBoolean:
    h = h !& hash(prs.bool)
  of pkFloat:
    h = h !& hash(prs.float)
  of pkDouble:
    h = h !& hash(prs.double)
  of pkSignedInteger:
    h = h !& hash(prs.int)
  of pkBigInteger:
    h = h !& hash(prs.bigint.flags)
    h = h !& hash(prs.bigint)
  of pkString:
    h = h !& hash(prs.string)
  of pkByteString:
    h = h !& hash(prs.bytes)
  of pkSymbol:
    h = h !& hash(prs.symbol)
  of pkRecord:
    for val in prs.record:
      h = h !& hash(val)
  of pkSequence:
    for val in prs.sequence:
      h = h !& hash(val)
  of pkSet:
    for val in prs.set.items:
      h = h !& hash(val)
  of pkDictionary:
    for (key, val) in prs.dict.pairs:
      h = h !& hash(val)
  of pkEmbedded:
    h = h !& hash(prs.embedded)
  !$h

proc `==`*(x, y: Preserve): bool =
  if x.kind == y.kind:
    case x.kind
    of pkBoolean:
      result = x.bool == y.bool
    of pkFloat:
      result = x.float == y.float
    of pkDouble:
      result = x.double == y.double
    of pkSignedInteger:
      result = x.int == y.int
    of pkBigInteger:
      result = x.bigint == y.bigint
    of pkString:
      result = x.string == y.string
    of pkByteString:
      result = x.bytes == y.bytes
    of pkSymbol:
      result = x.symbol == y.symbol
    of pkRecord:
      result = x.record == y.record
    of pkSequence:
      for i, val in x.sequence:
        if y.sequence[i] != val: return false
      result = true
    of pkSet:
      for val in x.set.items:
        if not y.set.contains(val): return false
      for val in y.set.items:
        if not x.set.contains(val): return false
      result = true
    of pkDictionary:
      for (key, val) in x.dict.pairs:
        if y.dict[key] != val: return false
      result = true
    of pkEmbedded:
      result = x.embedded == y.embedded

proc concat(result: var string; prs: Preserve) =
  case prs.kind:
  of pkBoolean:
    case prs.bool
    of false: result.add "#f"
    of true: result.add "#t"
  of pkFloat:
    result.add($prs.float & "f")
  of pkDouble:
    result.add $prs.double
  of pkSignedInteger:
    result.add $prs.int
  of pkBigInteger:
    result.add $prs.bigint
  of pkString:
    result.add escapeJson(prs.string)
  of pkByteString:
    for b in prs.bytes:
      if b.char notin {'\20'..'\21', '#'..'[', ']'..'~'}:
        result.add("#[") #]#
        result.add(base64.encode(prs.bytes))
        result.add(']')
        return
    result.add("#\"")
    result.add(cast[string](prs.bytes))
    result.add('"')
  of pkSymbol:
    result.add(escapeJsonUnquoted(prs.symbol))
  of pkRecord:
    assert(prs.record.len > 0)
    result.add('<')
    result.concat(prs.record[prs.record.high])
    for i in 0..<prs.record.high:
      result.add(' ')
      result.concat(prs.record[i])
    result.add('>')
  of pkSequence:
    result.add('[')
    for i, val in prs.sequence:
      if i > 0:
        result.add(' ')
      result.concat(val)
    result.add(']')
  of pkSet:
    result.add("#{")
    for val in prs.set.items:
      result.concat(val)
      result.add(' ')
    if prs.set.len > 1:
      result.setLen(result.high)
    result.add('}')
  of pkDictionary:
    result.add('{')
    var i = 0
    for (key, value) in prs.dict.pairs:
      if i > 0:
        result.add(' ')
      result.concat(key)
      result.add(": ")
      result.concat(value)
      inc i
    result.add('}')
  of pkEmbedded:
    result.add(prs.embedded.repr)

proc `$`*(prs: Preserve): string = concat(result, prs)

iterator items*(prs: Preserve): Preserve =
  case prs.kind
  of pkRecord:
    for i in 0..prs.record.high.pred:
      yield prs.record[i]
  of pkSequence:
    for e in prs.sequence.items: yield e
  of pkSet:
    for e in prs.set.items: yield e
  of pkDictionary:
    for k, v in prs.dict.pairs:
      yield k # key can be an arbitrary Preserve
      yield v
  else: discard

func isRecord*(prs: Preserve): bool =
  if prs.kind == pkRecord:
    result = true
    assert(prs.record.len > 0)

func isDictionary*(prs: Preserve): bool =
  prs.kind == pkDictionary

proc label*(prs: Preserve): Preserve {.inline.} =
  ## Return the label of a record value.
  prs.record[prs.record.high]

proc arity*(prs: Preserve): int {.inline.} =
  ## Return the number of fields in a record value.
  pred(prs.record.len)

proc fields*(prs: Preserve): seq[Preserve] {.inline.} =
  ## Return the fields of a record value.
  prs.record[0..prs.record.high.pred]

iterator fields*(prs: Preserve): Preserve =
  ## Iterate the fields of a record value.
  for i in 0..<prs.record.high: yield prs.record[i]

proc symbol*(s: string): Preserve {.inline.} =
  ## Symbol constructor.
  Preserve(kind: pkSymbol, symbol: s)

proc writeVarint(s: Stream; n: int) =
  var n = n
  while true:
    let c = int8(n and 0x7f)
    n = n shr 7
    if n == 0:
      s.write((char)c.char)
      break
    else:
      s.write((char)c or 0x80)

proc readVarint(s: Stream): int =
  var shift: int
  while shift < (9*8):
    let c = s.readChar.int
    result = result or ((c and 0x7f) shl shift)
    if (c and 0x80) == 0:
      break
    shift.inc 7

proc write*(str: Stream; prs: Preserve) =
  case prs.kind:
  of pkBoolean:
    case prs.bool
    of false: str.write(0x80'u8)
    of true: str.write(0x81'u8)
  of pkFloat:
    str.write(0x82'u8)
    when system.cpuEndian == bigEndian:
      str.write(prs.float)
    else:
      var be: float32
      swapEndian32(be.addr, prs.float.unsafeAddr)
      str.write(be)
  of pkDouble:
    str.write(0x83'u8)
    when system.cpuEndian == bigEndian:
      str.write(prs.double)
    else:
      var be: float64
      swapEndian64(be.addr, prs.double.unsafeAddr)
      str.write(be)
  of pkSignedInteger:
    if (-3 <= prs.int) and (prs.int <= 12):
      str.write(0x90'i8 or int8(if prs.int < 0: prs.int + 16 else: prs.int))
    else:
      var bitCount = 1'u8
      if prs.int < 0:
        while ((not prs.int) shr bitCount) != 0:
          inc(bitCount)
      else:
        while (prs.int shr bitCount) != 0:
          inc(bitCount)
      var byteCount = (bitCount + 8) div 8
      str.write(0xa0'u8 or (byteCount - 1))
      proc write(n: uint8; i: BiggestInt) =
        if n > 0:
          write(n.pred, i shr 8)
          str.write(i.uint8)
      write(byteCount, prs.int)
  of pkBigInteger:
    doAssert(Negative notin prs.bigint.flags, "negative big integers not implemented")
    var bytes = newSeqOfCap[uint8](prs.bigint.limbs.len * 4)
    var begun = false
    for i in countdown(prs.bigint.limbs.high, 0):
      let limb = prs.bigint.limbs[i]
      for j in countdown(24, 0, 8):
        let b = uint8(limb shr j)
        begun = begun or (b != 0)
        if begun:
          bytes.add(b)
    if bytes.len <= 16:
      str.write(0xa0'u8 or bytes.high.uint8)
    else:
      str.write(0xb0'u8)
      str.writeVarint(bytes.len)
    str.write(cast[string](bytes))
  of pkString:
    str.write(0xb1'u8)
    str.writeVarint(prs.string.len)
    str.write(prs.string)
  of pkByteString:
    str.write(0xb2'u8)
    str.writeVarint(prs.bytes.len)
    str.write(cast[string](prs.bytes))
  of pkSymbol:
    str.write(0xb3'u8)
    str.writeVarint(prs.symbol.len)
    str.write(prs.symbol)
  of pkRecord:
    assert(prs.record.len > 0)
    str.write(0xb4'u8)
    str.write(prs.record[prs.record.high])
    for i in 0..<prs.record.high:
      str.write(prs.record[i])
    str.write(0x84'u8)
  of pkSequence:
    str.write(0xb5'u8)
    for e in prs.sequence:
      str.write(e)
    str.write(0x84'u8)
  of pkSet:
    str.write(0xb6'u8)
    for val in prs.set.items:
      str.write(val)
    str.write(0x84'u8)
  of pkDictionary:
    str.write(0xb7'u8)
    for (key, value) in prs.dict.pairs:
      str.write(key)
      str.write(value)
    str.write(0x84'u8)
  of pkEmbedded:
    str.write(0x86'u8)
    raiseAssert("binary representation of embedded values is undefined")

proc encode*(prs: Preserve): string =
  let s = newStringStream()
  s.write prs
  s.setPosition 0
  result = s.readAll

proc decodePreserves*(s: Stream): Preserve =
  proc assertStream(check: bool) =
    if not check:
      raise newException(ValueError, "invalid Preserves stream")
  const endMarker = 0x84
  let tag = s.readUint8()
  case tag
  of 0x80: result = Preserve(kind: pkBoolean, bool: false)
  of 0x81: result = Preserve(kind: pkBoolean, bool: true)
  of 0x82:
    when system.cpuEndian == bigEndian:
      result = Preserve(kind: pkFloat, float: s.readFloat32())
    else:
      result = Preserve(kind: pkFloat)
      var be = s.readFloat32()
      swapEndian32(result.float.addr, be.addr)
  of 0x83:
    when system.cpuEndian == bigEndian:
      result = Preserve(kind: pkDouble, double: s.readFloat64())
    else:
      result = Preserve(kind: pkDouble)
      var be = s.readFloat64()
      swapEndian64(result.double.addr, be.addr)
  of 0x84:
    assertStream(false)
  of 0xb1:
    result = Preserve(kind: pkString)
    let len = s.readVarint()
    result.string = s.readStr(len)
  of 0xb2:
    result = Preserve(kind: pkByteString)
    let len = s.readVarint()
    result.bytes = cast[seq[byte]](s.readStr(len))
  of 0xb3:
    let len = s.readVarint()
    result = symbol(s.readStr(len))
  of 0xb4:
    result = Preserve(kind: pkRecord)
    var label = s.decodePreserves()
    while s.peekUint8() != endMarker:
      result.record.add(s.decodePreserves())
    result.record.add(label)
    discard s.readUint8()
  of 0xb5:
    result = Preserve(kind: pkSequence)
    while s.peekUint8() != endMarker:
      result.sequence.add(s.decodePreserves())
    discard s.readUint8()
  of 0xb6:
    result = Preserve(kind: pkSet)
    while s.peekUint8() != endMarker:
      result.set.incl(s.decodePreserves())
    discard s.readUint8()
  of 0xb7:
    result = Preserve(kind: pkDictionary)
    while s.peekUint8() != endMarker:
      let key = s.decodePreserves()
      let val = s.decodePreserves()
      result.dict[key] = val
    discard s.readUint8()
  of 0xb0:
    let len = s.readVarint()
    result = Preserve(kind: pkBigInteger, bigint: initBigint 0)
    for _ in 1..len:
      result.bigint = (result.bigint shl 8) + s.readUint8().int32
  else:
    case 0xf0 and tag
    of 0x90:
      var n = tag.BiggestInt
      result = Preserve(kind: pkSignedInteger,
          int: n - (if n > 0x9c: 0xa0 else: 0x90))
    of 0xa0:
      let len = (tag.int and 0x0f) + 1
      if len <= 8:
        result = Preserve(kind: pkSignedInteger, int: s.readUint8().BiggestInt)
        if (result.int and 0x80) != 0: result.int.dec(0x100)
        for i in 1..<len:
          result.int = (result.int shl 8) or s.readUint8().BiggestInt
      else:
        result = Preserve(kind: pkBigInteger)
        for i in 0..<len:
          result.bigint = (result.bigint shl 8) + s.readUint8().int32
    else:
      assertStream(false)

proc decodePreserves*(s: string): Preserve =
  s.newStringStream.decodePreserves

proc decodePreserves*(s: seq[byte]): Preserve =
  cast[string](s).newStringStream.decodePreserves

proc initDictionary*(): Preserve = Preserve(kind: pkDictionary)

template record*(label: string) {.pragma.}
  ## Serialize this object or tuple as a record.
  ##
  ## ```
  ##  type Foo {.record: "foobar".} = tuple
  ##    a, b: int
  ##  let r: Foo = (1, 2)
  ##  assert($r.toPreserve == "<foobar 1 2>")
  ## ```

template unpreservable*() {.pragma.}
  ## Pragma to forbid a type from being converted by `toPreserve`.

proc toPreserve*[T](x: T): Preserve =
  ## Serializes `x` to Preserves; uses `toPreserveHook(x: T)` if it's in scope to
  ## customize serialization.
  when T is Preserve: result = x
  elif compiles(toPreserveHook(x)):
    result = toPreserveHook(x)
  elif T is Bigint:
    result = Preserve(kind: pkBigInteger, bigint: x)
  elif T is seq[byte]:
    result = Preserve(kind: pkByteString, bytes: x)
  elif T is array | seq:
    result = Preserve(kind: pkSequence)
    for v in x.items: result.sequence.add(toPreserve(v))
  elif T is bool:
    result = Preserve(kind: pkBoolean, bool: x)
  elif T is distinct:
    result = toPreserve(x.distinctBase)
  elif T is float:
    result = Preserve(kind: pkFloat, float: x)
  elif T is float64:
    result = Preserve(kind: pkDouble, double: x)
  elif T is object | tuple:
    when T.hasCustomPragma(unpreservable): {.fatal: "unpreservable type".}
    elif T.hasCustomPragma(record):
      result = Preserve(kind: pkRecord)
      for _, f in x.fieldPairs: result.record.add(toPreserve(f))
      result.record.add(symbol(T.getCustomPragmaVal(record)))
    else:
      result = Preserve(kind: pkDictionary)
      for k, v in x.fieldPairs: result.dict[symbol(k)] = toPreserve(v)
  elif T is Ordinal:
    result = Preserve(kind: pkSignedInteger, int: x.ord.BiggestInt)
  elif T is ptr | ref:
    if system.`==`(x, nil): result = symbol"null"
    else: result = toPreserve(x[])
  elif T is string:
    result = Preserve(kind: pkString, string: x)
  elif T is SomeInteger:
    result = Preserve(kind: pkSignedInteger, int: x.BiggestInt)
  elif compiles(%x):
    result = %x
  else:
    raiseAssert("unpreservable type" & $T)

proc toPreserveHook*[T](set: HashSet[T]): Preserve =
  Preserve(kind: pkSet, set: set.map(toPreserve))

proc toPreserveHook*[A,B](table: Table[A,B]|TableRef[A,B]): Preserve =
  result = Preserve(kind: pkDictionary, dict: initTable[Preserve, Preserve](table.len))
  for k, v in table.pairs: result.dict[toPreserve k] = toPreserve v

proc fromPreserve*[T](v: var T; prs: Preserve): bool =
  ## Inplace version of `preserveTo`.
  ## Partial matches on compond values may leave artifacts in ``v``.
  # TODO: {.raises: [].}
  runnableExamples:
    import std/options, preserves, preserves/parse
    type Foo {.record: "foo".} = object
      x, y, z: int

    var foo: Foo
    assert(fromPreserve(foo, parsePreserves("""<foo 1 2 3>""")))
    assert(foo.x == 1)
    assert(foo.y == 2)
    assert(foo.z == 3)

  when compiles(fromPreserveHook(v, prs)):
    result = fromPreserveHook(v, prs)
  elif T is Preserve:
    v = prs
    result = true
  elif T is Bigint:
    case prs.kind
    of pkSignedInteger:
      v = initBigint(prs.int)
      result = true
    of pkBigInteger:
      v = prs.bigint
      result = true
    else: disard
  elif T is bool:
    if prs.kind == pkBoolean:
      v = prs.bool
      result = true
  elif T is SomeInteger:
    if prs.kind == pkSignedInteger:
      v = T(prs.int)
      result = true
  elif T is float:
    if prs.kind == pkFloat:
      v = prs.float
      result = true
  elif T is seq:
    if T is seq[byte] and prs.kind == pkByteString:
      v = prs.bytes
      result = true
    elif prs.kind == pkSequence:
      v.setLen(prs.len)
      result = true
      for i, e in prs.sequence:
        result = result and fromPreserve(v[i], e)
  elif T is float64:
    case prs.kind
    of pkFloat:
      v = prs.float
      result = true
    of pkDouble:
      v = prs.double
      result = true
  elif T is object | tuple:
    case prs.kind
    of pkRecord:
      when T.hasCustomPragma(record):
        const label = symbol(T.getCustomPragmaVal(record))
        if prs.record[prs.record.high] == label:
          result = true
          var i = 0
          for fname, field in v.fieldPairs:
            if not result or (i == prs.record.high): break
            result = result and fromPreserve(field, prs.record[i])
            inc(i)
          result = result and (i == prs.record.high) # arity equivalence check=
    of pkDictionary:
      result = true
      for key, val in v.fieldPairs:
        result = result and fromPreserve(val, prs.dict.getOrDefault(symbol(key)))
    else: discard
  elif T is Ordinal | SomeInteger:
    if prs.kind == pkSignedInteger:
      v = (T)prs.int
      result = true
  elif T is ref:
    if prs != symbol"null":
      new v
      result = fromPreserve(v[], prs)
  elif T is string:
    if prs.kind == pkString:
      v = prs.string
      result = true
  elif T is distinct:
    result = fromPreserve(result.distinctBase, prs)
  else:
    raiseAssert("no conversion of type Preserve to " & $T)

proc preserveTo*(prs: Preserve; T: typedesc): Option[T] =
  ## Reverse of `toPreserve`.
  # TODO: {.raises: [].}
  runnableExamples:
    import std/options, preserves, preserves/parse
    type Foo {.record: "foo".} = object
      x, y, z: int

    assert(parsePreserves("""<foo "abc">""").preserveTo(Foo).isNone)
    assert(parsePreserves("""<bar 1 2 3>""").preserveTo(Foo).isNone)
    assert(parsePreserves("""<foo 1 2 3>""").preserveTo(Foo).isSome)
  var v: T
  if fromPreserve(v, prs):
    result = some(move v)

proc fromPreserveHook*[A,B](t: var Table[A,B]|TableRef[A,B]; prs: Preserve): bool =
  if prs.isDictionary:
    for k, v in prs.pairs:
      t[preserveTo(k,A)] = preserveTo(k,B)
      result = true

proc len*(prs: Preserve): int =
  ## Return the number of values one level below ``prs``.
  case prs.kind
  of pkRecord: prs.record.len.pred
  of pkSequence: prs.sequence.len
  of pkSet: prs.set.len
  of pkDictionary: prs.dict.len
  else: 0

proc `[]`*(prs: Preserve; i: int): Preserve =
  case prs.kind
  of pkRecord: prs.record[i]
  of pkSequence: prs.sequence[i]
  else:
    raise newException(ValueError, "`[]` is not valid for " & $prs.kind)

proc initRecord*(label: Preserve; args: varargs[Preserve, toPreserve]): Preserve =
  ## Record constructor.
  result = Preserve(kind: pkRecord,
      record: newSeqOfCap[Preserve](1+args.len))
  for arg in args:
    assertValid(arg)
    result.record.add(arg)
  result.record.add(label)

proc initRecord*(label: string; args: varargs[Preserve, toPreserve]): Preserve {.inline.} =
  ## Record constructor that converts ``label`` to a symbol.
  initRecord(symbol(label), args)