#
#                 Ethereum P2P
#              (c) Copyright 2018
#       Status Research & Development GmbH
#
#            Licensed under either of
#  Apache License, version 2.0, (LICENSE-APACHEv2)
#            MIT license (LICENSE-MIT)

{.used.}

import
  std/[sequtils, options, tables],
  unittest2,
  nimcrypto/hash,
  ../../eth/[keys, rlp],
  ../../eth/p2p/rlpx_protocols/whisper/whisper_types as whisper

let rng = newRng()

suite "Whisper payload":
  test "should roundtrip without keys":
    let payload = Payload(payload: @[byte 0, 1, 2])
    let encoded = whisper.encode(rng[], payload)

    let decoded = whisper.decode(encoded.get())
    check:
      decoded.isSome()
      payload.payload == decoded.get().payload
      decoded.get().src.isNone()
      decoded.get().padding.get().len == 251 # 256 -1 -1 -3

  test "should roundtrip with symmetric encryption":
    var symKey: SymKey
    let payload = Payload(symKey: some(symKey), payload: @[byte 0, 1, 2])
    let encoded = whisper.encode(rng[], payload)

    let decoded = whisper.decode(encoded.get(), symKey = some(symKey))
    check:
      decoded.isSome()
      payload.payload == decoded.get().payload
      decoded.get().src.isNone()
      decoded.get().padding.get().len == 251 # 256 -1 -1 -3

  test "should roundtrip with signature":
    let privKey = PrivateKey.random(rng[])

    let payload = Payload(src: some(privKey), payload: @[byte 0, 1, 2])
    let encoded = whisper.encode(rng[], payload)

    let decoded = whisper.decode(encoded.get())
    check:
      decoded.isSome()
      payload.payload == decoded.get().payload
      privKey.toPublicKey() == decoded.get().src.get()
      decoded.get().padding.get().len == 186 # 256 -1 -1 -3 -65

  test "should roundtrip with asymmetric encryption":
    let privKey = PrivateKey.random(rng[])

    let payload = Payload(dst: some(privKey.toPublicKey()),
      payload: @[byte 0, 1, 2])
    let encoded = whisper.encode(rng[], payload)

    let decoded = whisper.decode(encoded.get(), dst = some(privKey))
    check:
      decoded.isSome()
      payload.payload == decoded.get().payload
      decoded.get().src.isNone()
      decoded.get().padding.get().len == 251 # 256 -1 -1 -3

  test "should return specified bloom":
    # Geth test: https://github.com/ethersphere/go-ethereum/blob/d3441ebb563439bac0837d70591f92e2c6080303/whisper/whisperv6/whisper_test.go#L834
    let top0 = [byte 0, 0, 255, 6]
    var x: Bloom
    x[0] = byte 1
    x[32] = byte 1
    x[^1] = byte 128
    check @(top0.topicBloom) == @x

suite "Whisper payload padding":
  test "should do max padding":
    let payload = Payload(payload: repeat(byte 1, 254))
    let encoded = whisper.encode(rng[], payload)

    let decoded = whisper.decode(encoded.get())
    check:
      decoded.isSome()
      payload.payload == decoded.get().payload
      decoded.get().padding.isSome()
      decoded.get().padding.get().len == 256 # as dataLen == 256

  test "should do max padding with signature":
    let privKey = PrivateKey.random(rng[])

    let payload = Payload(src: some(privKey), payload: repeat(byte 1, 189))
    let encoded = whisper.encode(rng[], payload)

    let decoded = whisper.decode(encoded.get())
    check:
      decoded.isSome()
      payload.payload == decoded.get().payload
      privKey.toPublicKey() == decoded.get().src.get()
      decoded.get().padding.isSome()
      decoded.get().padding.get().len == 256 # as dataLen == 256

  test "should do min padding":
    let payload = Payload(payload: repeat(byte 1, 253))
    let encoded = whisper.encode(rng[], payload)

    let decoded = whisper.decode(encoded.get())
    check:
      decoded.isSome()
      payload.payload == decoded.get().payload
      decoded.get().padding.isSome()
      decoded.get().padding.get().len == 1 # as dataLen == 255

  test "should do min padding with signature":
    let privKey = PrivateKey.random(rng[])

    let payload = Payload(src: some(privKey), payload: repeat(byte 1, 188))
    let encoded = whisper.encode(rng[], payload)

    let decoded = whisper.decode(encoded.get())
    check:
      decoded.isSome()
      payload.payload == decoded.get().payload
      privKey.toPublicKey() == decoded.get().src.get()
      decoded.get().padding.isSome()
      decoded.get().padding.get().len == 1 # as dataLen == 255

  test "should roundtrip custom padding":
    let payload = Payload(payload: repeat(byte 1, 10),
                          padding: some(repeat(byte 2, 100)))
    let encoded = whisper.encode(rng[], payload)

    let decoded = whisper.decode(encoded.get())
    check:
      decoded.isSome()
      payload.payload == decoded.get().payload
      decoded.get().padding.isSome()
      payload.padding.get() == decoded.get().padding.get()

  test "should roundtrip custom 0 padding":
    let padding: seq[byte] = @[]
    let payload = Payload(payload: repeat(byte 1, 10),
                          padding: some(padding))
    let encoded = whisper.encode(rng[], payload)

    let decoded = whisper.decode(encoded.get())
    check:
      decoded.isSome()
      payload.payload == decoded.get().payload
      decoded.get().padding.isNone()

  test "should roundtrip custom padding with signature":
    let privKey = PrivateKey.random(rng[])
    let payload = Payload(src: some(privKey), payload: repeat(byte 1, 10),
                          padding: some(repeat(byte 2, 100)))
    let encoded = whisper.encode(rng[], payload)

    let decoded = whisper.decode(encoded.get())
    check:
      decoded.isSome()
      payload.payload == decoded.get().payload
      privKey.toPublicKey() == decoded.get().src.get()
      decoded.get().padding.isSome()
      payload.padding.get() == decoded.get().padding.get()

  test "should roundtrip custom 0 padding with signature":
    let padding: seq[byte] = @[]
    let privKey = PrivateKey.random(rng[])
    let payload = Payload(src: some(privKey), payload: repeat(byte 1, 10),
                          padding: some(padding))
    let encoded = whisper.encode(rng[], payload)

    let decoded = whisper.decode(encoded.get())
    check:
      decoded.isSome()
      payload.payload == decoded.get().payload
      privKey.toPublicKey() == decoded.get().src.get()
      decoded.get().padding.isNone()

# example from https://github.com/paritytech/parity-ethereum/blob/93e1040d07e385d1219d00af71c46c720b0a1acf/whisper/src/message.rs#L439
let
  env0 = Envelope(
    expiry:100000, ttl: 30, topic: [byte 0, 0, 0, 0],
    data: repeat(byte 9, 256), nonce: 1010101)
  env1 = Envelope(
    expiry:100000, ttl: 30, topic: [byte 0, 0, 0, 0],
    data: repeat(byte 9, 256), nonce: 1010102)
  env2 = Envelope(
    expiry:100000, ttl: 30, topic: [byte 0, 0, 0, 0],
    data: repeat(byte 9, 256), nonce: 1010103)

suite "Whisper envelope":

  proc hashAndPow(env: Envelope): (string, float64) =
    # This is the current implementation of go-ethereum
    let size = env.toShortRlp().len().uint32
    # This is our current implementation in `whisper_protocol.nim`
    # let size = env.len().uint32
    # This is the EIP-627 specification
    # let size = env.toRlp().len().uint32
    let hash = env.calcPowHash()
    ($hash, calcPow(size, env.ttl, hash))

  test "PoW calculation leading zeroes tests":
    # Test values from Parity, in message.rs
    let testHashes = [
      # 256 leading zeroes
      "0x0000000000000000000000000000000000000000000000000000000000000000",
      # 255 leading zeroes
      "0x0000000000000000000000000000000000000000000000000000000000000001",
      # no leading zeroes
      "0xff00000000000000000000000000000000000000000000000000000000000000"
    ]
    check:
      calcPow(1, 1, Hash.fromHex(testHashes[0])) ==
        115792089237316200000000000000000000000000000000000000000000000000000000000000.0
      calcPow(1, 1, Hash.fromHex(testHashes[1])) ==
        57896044618658100000000000000000000000000000000000000000000000000000000000000.0
      calcPow(1, 1, Hash.fromHex(testHashes[2])) == 1.0

    # Test values from go-ethereum whisperv6 in envelope_test
    var env = Envelope(ttl: 1, data: @[byte 0xde, 0xad, 0xbe, 0xef])
    # PoW calculation with no leading zeroes
    env.nonce = 100000
    check hashAndPoW(env) == ("A788E02A95BFC673709E97CA81E39CA903BAD5638D3388964C51EB64952172D6",
                              0.07692307692307693)
    # PoW calculation with 8 leading zeroes
    env.nonce = 276
    check hashAndPoW(env) == ("00E2374C6353C243E4073E209A7F2ACB2506522AF318B3B78CF9A88310A2A11C",
                              19.692307692307693)

suite "Whisper queue":
  test "should throw out lower proof-of-work item when full":
    var queue = initQueue(1)

    let msg0 = initMessage(env0)
    let msg1 = initMessage(env1)

    discard queue.add(msg0)
    discard queue.add(msg1)

    check:
      queue.items.len() == 1
      queue.items[0].env.nonce ==
        (if msg0.pow > msg1.pow: msg0.env.nonce else: msg1.env.nonce)

  test "should not throw out messages as long as there is capacity":
    var queue = initQueue(2)

    check:
      queue.add(initMessage(env0)) == true
      queue.add(initMessage(env1)) == true

      queue.items.len() == 2

  test "check if order of queue is by decreasing PoW":
    var queue = initQueue(3)

    let msg0 = initMessage(env0)
    let msg1 = initMessage(env1)
    let msg2 = initMessage(env2)

    discard queue.add(msg0)
    discard queue.add(msg1)
    discard queue.add(msg2)

    check:
      queue.items.len() == 3
      queue.items[0].pow > queue.items[1].pow and
        queue.items[1].pow > queue.items[2].pow

  test "check field order against expected rlp order":
    check rlp.encode(env0) ==
      rlp.encodeList(env0.expiry, env0.ttl, env0.topic, env0.data, env0.nonce)

# To test filters we do not care if the msg is valid or allowed
proc prepFilterTestMsg(pubKey = none[PublicKey](), symKey = none[SymKey](),
                       src = none[PrivateKey](), topic: Topic,
                       padding = none[seq[byte]]()): Message =
    let payload = Payload(dst: pubKey, symKey: symKey, src: src,
                          payload: @[byte 0, 1, 2], padding: padding)
    let encoded = whisper.encode(rng[], payload)
    let env = Envelope(expiry: 1, ttl: 1, topic: topic, data: encoded.get(),
                       nonce: 0)
    result = initMessage(env)

suite "Whisper filter":
  test "should notify filter on message with symmetric encryption":
    var symKey: SymKey
    let topic = [byte 0, 0, 0, 0]
    let msg = prepFilterTestMsg(symKey = some(symKey), topic = topic)

    var filters = initTable[string, Filter]()
    let filter = initFilter(symKey = some(symKey), topics = @[topic])
    let filterId = subscribeFilter(rng[], filters, filter)

    notify(filters, msg)

    let messages = filters.getFilterMessages(filterId)
    check:
      messages.len == 1
      messages[0].decoded.src.isNone()
      messages[0].dst.isNone()

  test "should notify filter on message with asymmetric encryption":
    let privKey = PrivateKey.random(rng[])
    let topic = [byte 0, 0, 0, 0]
    let msg = prepFilterTestMsg(pubKey = some(privKey.toPublicKey()),
                                topic = topic)

    var filters = initTable[string, Filter]()
    let filter = initFilter(privateKey = some(privKey), topics = @[topic])
    let filterId = subscribeFilter(rng[], filters, filter)

    notify(filters, msg)

    let messages = filters.getFilterMessages(filterId)
    check:
      messages.len == 1
      messages[0].decoded.src.isNone()
      messages[0].dst.isSome()

  test "should notify filter on message with signature":
    let privKey = PrivateKey.random(rng[])
    let topic = [byte 0, 0, 0, 0]
    let msg = prepFilterTestMsg(src = some(privKey), topic = topic)

    var filters = initTable[string, Filter]()
    let filter = initFilter(src = some(privKey.toPublicKey()),
                           topics = @[topic])
    let filterId = subscribeFilter(rng[], filters, filter)

    notify(filters, msg)

    let messages = filters.getFilterMessages(filterId)
    check:
      messages.len == 1
      messages[0].decoded.src.isSome()
      messages[0].dst.isNone()

  test "test notify of filter against PoW requirement":
    let topic = [byte 0, 0, 0, 0]
    let padding = some(repeat(byte 0, 251))
    # this message has a PoW of 0.02962962962962963, number should be updated
    # in case PoW algorithm changes or contents of padding, payload, topic, etc.
    # update: now with NON rlp encoded envelope size the PoW of this message is
    # 0.014492753623188406
    let msg = prepFilterTestMsg(topic = topic, padding = padding)

    var filters = initTable[string, Filter]()
    let
      filterId1 = subscribeFilter(rng[], filters,
                    initFilter(topics = @[topic], powReq = 0.014492753623188406))
      filterId2 = subscribeFilter(rng[], filters,
                    initFilter(topics = @[topic], powReq = 0.014492753623188407))

    notify(filters, msg)

    check:
      filters.getFilterMessages(filterId1).len == 1
      filters.getFilterMessages(filterId2).len == 0

  test "test notify of filter on message with certain topic":
    let
      topic1 = [byte 0xAB, 0x12, 0xCD, 0x34]
      topic2 = [byte 0, 0, 0, 0]

    let msg = prepFilterTestMsg(topic = topic1)

    var filters = initTable[string, Filter]()
    let
      filterId1 = subscribeFilter(rng[], filters, initFilter(topics = @[topic1]))
      filterId2 = subscribeFilter(rng[], filters, initFilter(topics = @[topic2]))

    notify(filters, msg)

    check:
      filters.getFilterMessages(filterId1).len == 1
      filters.getFilterMessages(filterId2).len == 0