import
  faststreams/input_stream, eth/[common, rlp], stint, stew/endians2,
  eth/trie/[db, trie_defs], nimcrypto/[keccak, hash],
  ./witness_types, stew/byteutils

type
  DB = TrieDatabaseRef

  TreeBuilder = object
    data: seq[byte]
    pos: int
    #input: InputStream
    db: DB
    root: KeccakHash

# InputStream is unstable, so we hack our own inputstream
#proc initTreeBuilder*(input: InputStream, db: DB): TreeBuilder =
  #result.input = input
  #result.db = db
  #result.root = emptyRlpHash

proc initTreeBuilder*(input: openArray[byte], db: DB): TreeBuilder =
  result.data = @input
  result.db = db
  result.root = emptyRlpHash

func rootHash*(t: TreeBuilder): KeccakHash {.inline.} =
  t.root

proc writeNode(t: var TreeBuilder, n: openArray[byte]): KeccakHash =
  result = keccak(n)
  t.db.put(result.data, n)

proc readByte(t: var TreeBuilder): byte =
  if t.pos < t.data.len:
    result = t.data[t.pos]
    inc t.pos

template len(t: TreeBuilder): int =
  t.data.len

proc peek(t: TreeBuilder): byte =
  if t.pos + 1 < t.data.len:
    result = t.data[t.pos + 1]

template read(t: var TreeBuilder, len: int): auto =
  let pos = t.pos
  inc(t.pos, len)
  toOpenArray(t.data, pos, pos + len - 1)

proc readU32(t: var TreeBuilder): int =
  # TODO: what if the value overflow int32.high?
  result = fromBytesLE(uint32, t.read(4)).int

proc toAddress(r: var EthAddress, x: openArray[byte]) {.inline.} =
  r[0..19] = x[0..19]

proc toKeccak(r: var KeccakHash, x: openArray[byte]) {.inline.} =
  r.data[0..31] = x[0..31]

proc toKeccak(x: openArray[byte]): KeccakHash {.inline.} =
  result.data[0..31] = x[0..31]

proc branchNode(t: var TreeBuilder, depth: int, has16Elem: bool = true): KeccakHash
proc extensionNode(t: var TreeBuilder, depth: int): KeccakHash
proc accountNode(t: var TreeBuilder, depth: int): KeccakHash
proc accountStorageLeafNode(t: var TreeBuilder, depth: int): KeccakHash
proc hashNode(t: var TreeBuilder): KeccakHash

proc treeNode*(t: var TreeBuilder, depth: int = 0, accountMode = false): KeccakHash =
  assert(depth < 64)
  let nodeType = TrieNodeType(t.readByte)

  case nodeType
  of BranchNodeType: result = t.branchNode(depth)
  of Branch17NodeType: result = t.branchNode(depth, false)
  of ExtensionNodeType: result = t.extensionNode(depth)
  of AccountNodeType:
    if accountMode:
      # parse account storage leaf node
      result = t.accountStorageLeafNode(depth)
    else:
      result = t.accountNode(depth)
  of HashNodeType: result = t.hashNode()

proc branchNode(t: var TreeBuilder, depth: int, has16Elem: bool): KeccakHash =
  assert(depth < 64)
  let mask = constructBranchMask(t.readByte, t.readByte)
  var r = initRlpList(17)

  for i in 0 ..< 16:
    if mask.branchMaskBitIsSet(i):
      r.append t.treeNode(depth+1)
    else:
      r.append ""

  template safePeek(t: var TreeBuilder): int =
    if t.len == 0 or has16Elem:
      -1
    else:
      t.peek().int

  # add the 17th elem
  let nodeType = t.safePeek()
  if nodeType == AccountNodeType.int:
    r.append accountNode(t, depth+1)
  elif nodeType == HashNodeType.int:
    r.append hashNode(t)
  else:
    # anything else is empty
    r.append ""

  result = keccak(r.finish)

func hexPrefix(r: var RlpWriter, x: openArray[byte], nibblesLen: int) =
  var bytes: array[33, byte]
  if (nibblesLen mod 2) == 0:
    bytes[0] = 0.byte
    var i = 1
    for y in x:
      bytes[i] = y
      inc i
  else:
    bytes[0] = 0b0001_0000.byte or (x[0] shr 4)
    var last = nibblesLen div 2
    for i in 1..last:
      bytes[i] = (x[i-1] shl 4) or (x[i] shr 4)
      
  r.append toOpenArray(bytes, 0, nibblesLen div 2)

proc extensionNode(t: var TreeBuilder, depth: int): KeccakHash =
  assert(depth < 63)
  let nibblesLen = int(t.readByte)
  assert(nibblesLen < 65)
  var r = initRlpList(2)
  r.hexPrefix(t.read(nibblesLen div 2 + nibblesLen mod 2), nibblesLen)

  assert(depth + nibblesLen < 65)
  let nodeType = TrieNodeType(t.readByte)

  case nodeType
  of BranchNodeType: r.append t.branchNode(depth + nibblesLen)
  of Branch17NodeType: r.append t.branchNode(depth + nibblesLen, false)
  of HashNodeType: r.append t.hashNode()
  else: raise newException(ValueError, "wrong type during parsing child of extension node")

  result = keccak(r.finish)

proc accountNode(t: var TreeBuilder, depth: int): KeccakHash =
  assert(depth < 65)
  let len = t.readU32()
  t.writeNode(t.read(len))

  #[let nodeType = AccountType(t.readByte)
  let nibblesLen = 64 - depth
  let pathNibbles = @(t.read(nibblesLen div 2 + nibblesLen mod 2))
  let address = toAddress(t.read(20))
  let balance = UInt256.fromBytesBE(t.read(32), false)
  # TODO: why nonce must be 32 bytes, isn't 64 bit uint  enough?
  let nonce = UInt256.fromBytesBE(t.read(32), false)
  if nodeType == ExtendedAccountType:
    let codeLen = t.readU32()
    let code = @(t.read(codeLen))
    # switch to account storage parsing mode
    # and reset the depth
    t.treeNode(0, accountMode = true)]#

proc accountStorageLeafNode(t: var TreeBuilder, depth: int): KeccakHash =
  assert(depth < 65)
  let nibblesLen = 64 - depth
  let pathNibbles = @(t.read(nibblesLen div 2 + nibblesLen mod 2))
  let key = @(t.read(32))
  let val = @(t.read(32))

proc hashNode(t: var TreeBuilder): KeccakHash =
  result.toKeccak(t.read(32))