import
  std/tables,
  stew/byteutils,
  chronicles,
  unittest2,
  nimcrypto/sysrand,
  chronos,
  "."/[test_env, helper, types],
  ../../../nimbus/transaction,
  ../../../nimbus/rpc/rpc_types,
  ../../../nimbus/rpc/merge/mergeutils

const
  prevRandaoContractAddr = hexToByteArray[20]("0000000000000000000000000000000000000316")

proc `==`(a: Option[BlockHash], b: Option[Hash256]): bool =
  if a.isNone and b.isNone:
    return true
  if a.isSome and b.isSome:
    return a.get() == b.get().data.BlockHash

template testFCU(res, cond: untyped, validHash: Option[Hash256], id = none(PayloadID)) =
  testCond res.isOk
  let s = res.get()
  testCond s.payloadStatus.status == PayloadExecutionStatus.cond:
    error "Unexpected FCU status", expect=PayloadExecutionStatus.cond, get=s.payloadStatus.status
  testCond s.payloadStatus.latestValidHash == validHash:
    error "Unexpected FCU latestValidHash", expect=validHash, get=s.payloadStatus.latestValidHash
  testCond s.payloadId == id:
    error "Unexpected FCU payloadID", expect=id, get=s.payloadId

template testFCU(res, cond: untyped) =
  testCond res.isOk
  let s = res.get()
  testCond s.payloadStatus.status == PayloadExecutionStatus.cond:
    error "Unexpected FCU status", expect=PayloadExecutionStatus.cond, get=s.payloadStatus.status

template testNP(res, cond: untyped, validHash = none(Hash256)) =
  testCond res.isOk
  let s = res.get()
  testCond s.status == PayloadExecutionStatus.cond:
    error "Unexpected NewPayload status", expect=PayloadExecutionStatus.cond, get=s.status
  testCond s.latestValidHash == validHash:
    error "Unexpected NewPayload latestValidHash", expect=validHash, get=s.latestValidHash

template testNPEither(res, cond: untyped, validHash = none(Hash256)) =
  testCond res.isOk
  let s = res.get()
  testCond s.status in cond:
    error "Unexpected NewPayload status", expect=cond, get=s.status
  testCond s.latestValidHash == validHash:
    error "Unexpected NewPayload latestValidHash", expect=validHash, get=s.latestValidHash

template testLatestHeader(client: untyped, expectedHash: BlockHash) =
  var lastHeader: EthBlockHeader
  var hRes = client.latestHeader(lastHeader)
  testCond hRes.isOk:
    error "unable to get latest header", msg=hRes.error

  let lastHash = BlockHash lastHeader.blockHash.data
  # Latest block header available via Eth RPC should not have changed at this point
  testCond lastHash == expectedHash:
    error "latest block header incorrect",
      expect = expectedHash,
      get = lastHash

proc sendTx(t: TestEnv, recipient: EthAddress, val: UInt256, data: openArray[byte] = []): bool =
  t.tx = t.makeNextTransaction(recipient, val, data)
  let rr = t.rpcClient.sendTransaction(t.tx)
  if rr.isErr:
    error "Unable to send transaction", msg=rr.error
    return false
  return true

proc sendTx(t: TestEnv, val: UInt256): bool =
  t.sendTx(prevRandaoContractAddr, val)

# Invalid Terminal Block in ForkchoiceUpdated:
# Client must reject ForkchoiceUpdated directives if the referenced HeadBlockHash does not meet the TTD requirement.
proc invalidTerminalBlockForkchoiceUpdated(t: TestEnv): TestStatus =
  result = TestStatus.OK

  let
    gHash = Web3BlockHash t.gHeader.blockHash.data
    forkchoiceState = ForkchoiceStateV1(
      headBlockHash:      gHash,
      safeBlockHash:      gHash,
      finalizedBlockHash: gHash,
    )

  let res = t.rpcClient.forkchoiceUpdatedV1(forkchoiceState)
  # Execution specification:
  # {payloadStatus: {status: INVALID, latestValidHash=0x00..00}, payloadId: null}
  # either obtained from the Payload validation process or as a result of validating a PoW block referenced by forkchoiceState.headBlockHash

  testFCU(res, invalid, some(Hash256()))
  # ValidationError is not validated since it can be either null or a string message

  # Check that PoW chain progresses
  testCond t.verifyPoWProgress(t.gHeader.blockHash)

# Invalid GetPayload Under PoW: Client must reject GetPayload directives under PoW.
proc invalidGetPayloadUnderPoW(t: TestEnv): TestStatus =
  result = TestStatus.OK

  # We start in PoW and try to get an invalid Payload, which should produce an error but nothing should be disrupted.
  let id = PayloadID [1.byte, 2,3,4,5,6,7,8]
  let res = t.rpcClient.getPayloadV1(id)
  testCond res.isErr

  # Check that PoW chain progresses
  testCond t.verifyPoWProgress(t.gHeader.blockHash)

# Invalid Terminal Block in NewPayload:
# Client must reject NewPayload directives if the referenced ParentHash does not meet the TTD requirement.
proc invalidTerminalBlockNewPayload(t: TestEnv): TestStatus =
  result = TestStatus.OK

  let gBlock = t.gHeader
  let payload = ExecutableData(
    parentHash:   gBlock.blockHash,
    stateRoot:    gBlock.stateRoot,
    receiptsRoot: EMPTY_ROOT_HASH,
    number:       1,
    gasLimit:     gBlock.gasLimit,
    gasUsed:      0,
    timestamp:    gBlock.timestamp + 1.seconds,
    baseFeePerGas:gBlock.baseFee
  )
  let hashedPayload = customizePayload(payload, CustomPayload())
  let res = t.rpcClient.newPayloadV1(hashedPayload)

  # Execution specification:
  # {status: INVALID, latestValidHash=0x00..00}
  # if terminal block conditions are not satisfied
  testNP(res, invalid, some(Hash256()))

  # Check that PoW chain progresses
  testCond t.verifyPoWProgress(t.gHeader.blockHash)

proc unknownHeadBlockHash(t: TestEnv): TestStatus =
  result = TestStatus.OK

  let ok = waitFor t.clMock.waitForTTD()
  testCond ok

  var randomHash: Hash256
  testCond randomBytes(randomHash.data) == 32

  let clMock = t.clMock
  let forkchoiceStateUnknownHeadHash = ForkchoiceStateV1(
    headBlockHash:      BlockHash randomHash.data,
    safeBlockHash:      clMock.latestForkchoice.finalizedBlockHash,
    finalizedBlockHash: clMock.latestForkchoice.finalizedBlockHash,
  )

  var res = t.rpcClient.forkchoiceUpdatedV1(forkchoiceStateUnknownHeadHash)
  testCond res.isOk

  let s = res.get()
  # Execution specification::
  # - {payloadStatus: {status: SYNCING, latestValidHash: null, validationError: null}, payloadId: null}
  #   if forkchoiceState.headBlockHash references an unknown payload or a payload that can't be validated
  #   because requisite data for the validation is missing
  testCond s.payloadStatus.status == PayloadExecutionStatus.syncing

  # Test again using PayloadAttributes, should also return SYNCING and no PayloadID
  let timestamp = uint64 clMock.latestExecutedPayload.timestamp
  let payloadAttr = PayloadAttributesV1(
    timestamp: Quantity(timestamp + 1)
  )

  res = t.rpcClient.forkchoiceUpdatedV1(forkchoiceStateUnknownHeadHash, some(payloadAttr))
  testCond res.isOk
  testCond s.payloadStatus.status == PayloadExecutionStatus.syncing
  testCond s.payloadId.isNone

proc unknownSafeBlockHash(t: TestEnv): TestStatus =
  result = TestStatus.OK

  let ok = waitFor t.clMock.waitForTTD()
  testCond ok

  # Produce blocks before starting the test
  let produce5BlockRes = t.clMock.produceBlocks(5, BlockProcessCallbacks())
  testCond produce5BlockRes

  let clMock = t.clMock
  let client = t.rpcClient
  let produceSingleBlockRes = clMock.produceSingleBlock(BlockProcessCallbacks(
    # Run test after a new payload has been broadcast
    onNewPayloadBroadcast: proc(): bool =
      # Generate a random SafeBlock hash
      var randomSafeBlockHash: Hash256
      doAssert randomBytes(randomSafeBlockHash.data) == 32

      # Send forkchoiceUpdated with random SafeBlockHash
      let forkchoiceStateUnknownSafeHash = ForkchoiceStateV1(
        headBlockHash:      clMock.latestExecutedPayload.blockHash,
        safeBlockHash:      BlockHash randomSafeBlockHash.data,
        finalizedBlockHash: clMock.latestForkchoice.finalizedBlockHash,
      )
      # Execution specification:
      # - This value MUST be either equal to or an ancestor of headBlockHash
      let res = client.forkchoiceUpdatedV1(forkchoiceStateUnknownSafeHash)
      return res.isErr
  ))

  testCond produceSingleBlockRes

proc unknownFinalizedBlockHash(t: TestEnv): TestStatus =
  result = TestStatus.OK

  let ok = waitFor t.clMock.waitForTTD()
  testCond ok

  # Produce blocks before starting the test
  let produce5BlockRes = t.clMock.produceBlocks(5, BlockProcessCallbacks())
  testCond produce5BlockRes

  let clMock = t.clMock
  let client = t.rpcClient
  let produceSingleBlockRes = clMock.produceSingleBlock(BlockProcessCallbacks(
    # Run test after a new payload has been broadcast
    onNewPayloadBroadcast: proc(): bool =
      # Generate a random SafeBlock hash
      var randomFinalBlockHash: Hash256
      doAssert randomBytes(randomFinalBlockHash.data) == 32

      # Send forkchoiceUpdated with random SafeBlockHash
      let forkchoiceStateUnknownFinalizedHash = ForkchoiceStateV1(
        headBlockHash:      clMock.latestExecutedPayload.blockHash,
        safeBlockHash:      clMock.latestForkchoice.safeBlockHash,
        finalizedBlockHash: BlockHash randomFinalBlockHash.data,
      )
      # Execution specification:
      # - This value MUST be either equal to or an ancestor of headBlockHash
      var res = client.forkchoiceUpdatedV1(forkchoiceStateUnknownFinalizedHash)
      if res.isOk:
        return false

      # Test again using PayloadAttributes, should also return INVALID and no PayloadID
      let timestamp = uint64 clMock.latestExecutedPayload.timestamp
      let payloadAttr = PayloadAttributesV1(
        timestamp:  Quantity(timestamp + 1)
      )
      res = client.forkchoiceUpdatedV1(forkchoiceStateUnknownFinalizedHash, some(payloadAttr))
      return res.isErr
  ))

  testCond produceSingleBlockRes

# Send an inconsistent ForkchoiceState with a known payload that belongs to a side chain as head, safe or finalized.
type
  Inconsistency {.pure.} = enum
    Head
    Safe
    Finalized

  PayloadList = ref object
    canonicalPayloads  : seq[ExecutableData]
    alternativePayloads: seq[ExecutableData]

template inconsistentForkchoiceStateGen(procname: untyped, inconsistency: Inconsistency) =
  proc procName(t: TestEnv): TestStatus =
    result = TestStatus.OK

    # Wait until TTD is reached by this client
    let ok = waitFor t.clMock.waitForTTD()
    testCond ok

    var pList = PayloadList()
    let clMock = t.clMock
    let client = t.rpcClient

    # Produce blocks before starting the test
    let produceBlockRes = clMock.produceBlocks(3, BlockProcessCallbacks(
      onGetPayload: proc(): bool =
        # Generate and send an alternative side chain
        var customData = CustomPayload(
          extraData: some(@[0x01.byte])
        )

        if pList.alternativePayloads.len > 0:
          customData.parentHash = some(pList.alternativePayloads[^1].blockHash)

        let executableData = toExecutableData(clMock.latestPayloadBuilt)
        let alternativePayload = customizePayload(executableData, customData)
        pList.alternativePayloads.add(alternativePayload.toExecutableData)

        let latestCanonicalPayload = toExecutableData(clMock.latestPayloadBuilt)
        pList.canonicalPayloads.add(latestCanonicalPayload)

        # Send the alternative payload
        let res = client.newPayloadV1(alternativePayload)
        if res.isErr:
          return false

        let s = res.get()
        s.status == PayloadExecutionStatus.valid or s.status == PayloadExecutionStatus.accepted
    ))

    testCond produceBlockRes

    # Send the invalid ForkchoiceStates
    let len = pList.alternativePayloads.len
    var inconsistentFcU = ForkchoiceStateV1(
      headBlockHash:      Web3BlockHash pList.canonicalPayloads[len-1].blockHash.data,
      safeBlockHash:      Web3BlockHash pList.canonicalPayloads[len-2].blockHash.data,
      finalizedBlockHash: Web3BlockHash pList.canonicalPayloads[len-3].blockHash.data,
    )

    when inconsistency == Inconsistency.Head:
      inconsistentFcU.headBlockHash = Web3BlockHash pList.alternativePayloads[len-1].blockHash.data
    elif inconsistency == Inconsistency.Safe:
      inconsistentFcU.safeBlockHash = Web3BlockHash pList.alternativePayloads[len-2].blockHash.data
    else:
      inconsistentFcU.finalizedBlockHash = Web3BlockHash pList.alternativePayloads[len-3].blockHash.data

    var r = client.forkchoiceUpdatedV1(inconsistentFcU)
    testCond r.isErr

    # Return to the canonical chain
    r = client.forkchoiceUpdatedV1(clMock.latestForkchoice)
    testCond r.isOk
    let s = r.get()
    testCond s.payloadStatus.status == PayloadExecutionStatus.valid

inconsistentForkchoiceStateGen(inconsistentForkchoiceState1, Inconsistency.Head)
inconsistentForkchoiceStateGen(inconsistentForkchoiceState2, Inconsistency.Safe)
inconsistentForkchoiceStateGen(inconsistentForkchoiceState3, Inconsistency.Finalized)

# Verify behavior on a forkchoiceUpdated with invalid payload attributes
template invalidPayloadAttributesGen(procname: untyped, syncingCond: bool) =
  proc procName(t: TestEnv): TestStatus =
    result = TestStatus.OK

    # Wait until TTD is reached by this client
    let ok = waitFor t.clMock.waitForTTD()
    testCond ok

    let clMock = t.clMock
    let client = t.rpcClient

    # Produce blocks before starting the test
    var produceBlockRes = clMock.produceBlocks(5, BlockProcessCallbacks())
    testCond produceBlockRes

    # Send a forkchoiceUpdated with invalid PayloadAttributes
    produceBlockRes = clMock.produceSingleBlock(BlockProcessCallbacks(
      onNewPayloadBroadcast: proc(): bool =
        # Try to apply the new payload with invalid attributes
        var blockHash: Hash256
        when syncingCond:
          # Setting a random hash will put the client into `SYNCING`
          doAssert randomBytes(blockHash.data) == 32
        else:
          # Set the block hash to the next payload that was broadcasted
          blockHash = hash256(clMock.latestPayloadBuilt.blockHash)

        let fcu = ForkchoiceStateV1(
          headBlockHash:      Web3BlockHash blockHash.data,
          safeBlockHash:      Web3BlockHash blockHash.data,
          finalizedBlockHash: Web3BlockHash blockHash.data,
        )

        let attr = PayloadAttributesV1()

        # 0) Check headBlock is known and there is no missing data, if not respond with SYNCING
        # 1) Check headBlock is VALID, if not respond with INVALID
        # 2) Apply forkchoiceState
        # 3) Check payloadAttributes, if invalid respond with error: code: Invalid payload attributes
        # 4) Start payload build process and respond with VALID
        when syncingCond:
          # If we are SYNCING, the outcome should be SYNCING regardless of the validity of the payload atttributes
          let r = client.forkchoiceUpdatedV1(fcu, some(attr))
          testFCU(r, syncing)
        else:
          let r = client.forkchoiceUpdatedV1(fcu, some(attr))
          testCond r.isOk:
            error "Unexpected error", msg = r.error

          # Check that the forkchoice was applied, regardless of the error
          testLatestHeader(client, BlockHash blockHash.data)
        return true
    ))

    testCond produceBlockRes

invalidPayloadAttributesGen(invalidPayloadAttributes1, false)
invalidPayloadAttributesGen(invalidPayloadAttributes2, true)

proc preTTDFinalizedBlockHash(t: TestEnv): TestStatus =
  result = TestStatus.OK

  let ok = waitFor t.clMock.waitForTTD()
  testCond ok

  # Produce blocks before starting the test
  let produce5BlockRes = t.clMock.produceBlocks(5, BlockProcessCallbacks())
  testCond produce5BlockRes

  let
    gHash = Web3BlockHash t.gHeader.blockHash.data
    forkchoiceState = ForkchoiceStateV1(
      headBlockHash:      gHash,
      safeBlockHash:      gHash,
      finalizedBlockHash: gHash,
    )
    client = t.rpcClient
    clMock = t.clMock

  var res = client.forkchoiceUpdatedV1(forkchoiceState)
  testFCU(res, invalid, some(Hash256()))

  res = client.forkchoiceUpdatedV1(clMock.latestForkchoice)
  testFCU(res, valid)

# Corrupt the hash of a valid payload, client should reject the payload.
# All possible scenarios:
#    (fcU)
# ┌────────┐        ┌────────────────────────┐
# │  HEAD  │◄───────┤ Bad Hash (!Sync,!Side) │
# └────┬───┘        └────────────────────────┘
#    │
#    │
# ┌────▼───┐        ┌────────────────────────┐
# │ HEAD-1 │◄───────┤ Bad Hash (!Sync, Side) │
# └────┬───┘        └────────────────────────┘
#    │
#
#
#   (fcU)
# ********************  ┌───────────────────────┐
# *  (Unknown) HEAD  *◄─┤ Bad Hash (Sync,!Side) │
# ********************  └───────────────────────┘
#    │
#    │
# ┌────▼───┐            ┌───────────────────────┐
# │ HEAD-1 │◄───────────┤ Bad Hash (Sync, Side) │
# └────┬───┘            └───────────────────────┘
#    │
#

type
  Shadow = ref object
    hash: Hash256

template badHashOnNewPayloadGen(procname: untyped, syncingCond: bool, sideChain: bool) =
  proc procName(t: TestEnv): TestStatus =
    result = TestStatus.OK

    let ok = waitFor t.clMock.waitForTTD()
    testCond ok

    # Produce blocks before starting the test
    let produce5BlockRes = t.clMock.produceBlocks(5, BlockProcessCallbacks())
    testCond produce5BlockRes

    let clMock = t.clMock
    let client = t.rpcClient
    let shadow = Shadow()

    var produceSingleBlockRes = clMock.produceSingleBlock(BlockProcessCallbacks(
      # Run test after the new payload has been obtained
      onGetPayload: proc(): bool =
        # Alter hash on the payload and send it to client, should produce an error
        var alteredPayload = clMock.latestPayloadBuilt
        var invalidPayloadHash = hash256(alteredPayload.blockHash)
        let lastByte = int invalidPayloadHash.data[^1]
        invalidPayloadHash.data[^1] = byte(not lastByte)
        shadow.hash = invalidPayloadHash
        alteredPayload.blockHash = BlockHash invalidPayloadHash.data

        when not syncingCond and sideChain:
          # We alter the payload by setting the parent to a known past block in the
          # canonical chain, which makes this payload a side chain payload, and also an invalid block hash
          # (because we did not update the block hash appropriately)
          alteredPayload.parentHash = Web3BlockHash clMock.latestHeader.parentHash.data
        elif syncingCond:
          # We need to send an fcU to put the client in SYNCING state.
          var randomHeadBlock: Hash256
          doAssert randomBytes(randomHeadBlock.data) == 32

          let latestHeaderHash = clMock.latestHeader.blockHash
          let fcU = ForkchoiceStateV1(
            headBlockHash:      Web3BlockHash randomHeadBlock.data,
            safeBlockHash:      Web3BlockHash latestHeaderHash.data,
            finalizedBlockHash: Web3BlockHash latestHeaderHash.data
          )

          let r = client.forkchoiceUpdatedV1(fcU)
          if r.isErr:
            return false
          let z = r.get()
          if z.payloadStatus.status != PayloadExecutionStatus.syncing:
            return false

          when sidechain:
            # Syncing and sidechain, the caonincal head is an unknown payload to us,
            # but this specific bad hash payload is in theory part of a side chain.
            # Therefore the parent we use is the head hash.
            alteredPayload.parentHash = Web3BlockHash latestHeaderHash.data
          else:
            # The invalid bad-hash payload points to the unknown head, but we know it is
            # indeed canonical because the head was set using forkchoiceUpdated.
            alteredPayload.parentHash = Web3BlockHash randomHeadBlock.data

        let res = client.newPayloadV1(alteredPayload)
        # Execution specification::
        # - {status: INVALID_BLOCK_HASH, latestValidHash: null, validationError: null} if the blockHash validation has failed
        if res.isErr:
          return false
        let s = res.get()
        if s.status != PayloadExecutionStatus.invalid_block_hash:
          return false
        s.latestValidHash.isNone
    ))
    testCond produceSingleBlockRes

    # Lastly, attempt to build on top of the invalid payload
    produceSingleBlockRes = clMock.produceSingleBlock(BlockProcessCallbacks(
      # Run test after the new payload has been obtained
      onGetPayload: proc(): bool =
        let payload = toExecutableData(clMock.latestPayloadBuilt)
        let alteredPayload = customizePayload(payload, CustomPayload(
          parentHash: some(shadow.hash),
        ))
        let res = client.newPayloadV1(alteredPayload)
        if res.isErr:
          return false
        # Response status can be ACCEPTED (since parent payload could have been thrown out by the client)
        # or INVALID (client still has the payload and can verify that this payload is incorrectly building on top of it),
        # but a VALID response is incorrect.
        let s = res.get()
        s.status != PayloadExecutionStatus.valid
    ))
    testCond produceSingleBlockRes

badHashOnNewPayloadGen(badHashOnNewPayload1, false, false)
badHashOnNewPayloadGen(badHashOnNewPayload2, true, false)
badHashOnNewPayloadGen(badHashOnNewPayload3, false, true)
badHashOnNewPayloadGen(badHashOnNewPayload4, true, true)

proc parentHashOnExecPayload(t: TestEnv): TestStatus =
  result = TestStatus.OK

  # Wait until TTD is reached by this client
  let ok = waitFor t.clMock.waitForTTD()
  testCond ok

  # Produce blocks before starting the test
  let produce5BlockRes = t.clMock.produceBlocks(5, BlockProcessCallbacks())
  testCond produce5BlockRes

  let clMock = t.clMock
  let client = t.rpcClient
  var produceSingleBlockRes = clMock.produceSingleBlock(BlockProcessCallbacks(
    # Run test after the new payload has been obtained
    onGetPayload: proc(): bool =
      # Alter hash on the payload and send it to client, should produce an error
      var alteredPayload = clMock.latestPayloadBuilt
      alteredPayload.blockHash = alteredPayload.parentHash
      let res = client.newPayloadV1(alteredPayload)
      if res.isErr:
        return false
      # Execution specification::
      # - {status: INVALID_BLOCK_HASH, latestValidHash: null, validationError: null} if the blockHash validation has failed
      let s = res.get()
      s.status == PayloadExecutionStatus.invalid_block_hash
  ))
  testCond produceSingleBlockRes

# Attempt to re-org to a chain containing an invalid transition payload
proc invalidTransitionPayload(t: TestEnv): TestStatus =
  result = TestStatus.OK

  # Wait until TTD is reached by main client
  let ok = waitFor t.clMock.waitForTTD()
  testCond ok

  let clMock = t.clMock
  let client = t.rpcClient

  # Produce two blocks before trying to re-org
  t.nonce = 2 # Initial PoW chain already contains 2 transactions
  var pbRes = clMock.produceBlocks(2, BlockProcessCallbacks(
    onPayloadProducerSelected: proc(): bool =
      t.sendTx(1.u256)
  ))

  testCond pbRes

  # Introduce the invalid transition payload
  pbRes = clMock.produceSingleBlock(BlockProcessCallbacks(
    # This is being done in the middle of the block building
    # process simply to be able to re-org back.
    onGetPayload: proc(): bool =
      let basePayload = clMock.executedPayloadHistory[clMock.posBlockNumber]
      let alteredPayload = generateInvalidPayload(basePayload, InvalidStateRoot)

      let res = client.newPayloadV1(alteredPayload)
      let cond = {PayloadExecutionStatus.invalid, PayloadExecutionStatus.accepted}
      testNPEither(res, cond, some(Hash256()))

      let rr = client.forkchoiceUpdatedV1(
        ForkchoiceStateV1(headBlockHash: alteredPayload.blockHash)
      )
      testFCU(rr, invalid, some(Hash256()))

      testLatestHeader(client, clMock.latestExecutedPayload.blockHash)
      return true
  ))

  testCond pbRes

template invalidPayloadTestCaseGen(procName: untyped, payloadField: InvalidPayloadField, emptyTxs: bool = false) =
  proc procName(t: TestEnv): TestStatus =
    result = TestStatus.OK

    # Wait until TTD is reached by this client
    let ok = waitFor t.clMock.waitForTTD()
    testCond ok

    let clMock = t.clMock
    let client = t.rpcClient

    template txProc(): bool =
      when not emptyTxs:
        t.sendTx(0.u256)
      else:
        true

    # Produce blocks before starting the test
    var pbRes = clMock.produceBlocks(5, BlockProcessCallbacks(
      # Make sure at least one transaction is included in each block
      onPayloadProducerSelected: proc(): bool =
        txProc()
    ))

    testCond pbRes

    let invalidPayload = Shadow()

    pbRes = clMock.produceSingleBlock(BlockProcessCallbacks(
      # Make sure at least one transaction is included in the payload
      onPayloadProducerSelected: proc(): bool =
        txProc()
      ,
      # Run test after the new payload has been obtained
      onGetPayload: proc(): bool =
        # Alter the payload while maintaining a valid hash and send it to the client, should produce an error

        # We need at least one transaction for most test cases to work
        when not emptyTxs:
          if clMock.latestPayloadBuilt.transactions.len == 0:
            # But if the payload has no transactions, the test is invalid
            error "No transactions in the base payload"
            return false

        let alteredPayload = generateInvalidPayload(clMock.latestPayloadBuilt, payloadField, t.vaultKey)
        invalidPayload.hash = hash256(alteredPayload.blockHash)

        # Depending on the field we modified, we expect a different status
        let rr = client.newPayloadV1(alteredPayload)
        if rr.isErr:
          error "unable to send altered payload", msg=rr.error
          return false
        let s = rr.get()

        when payloadField == InvalidParentHash:
          # Execution specification::
          # {status: ACCEPTED, latestValidHash: null, validationError: null} if the following conditions are met:
          #  - the blockHash of the payload is valid
          #  - the payload doesn't extend the canonical chain
          #  - the payload hasn't been fully validated
          # {status: SYNCING, latestValidHash: null, validationError: null}
          # if the payload extends the canonical chain and requisite data for its validation is missing
          # (the client can assume the payload extends the canonical because the linking payload could be missing)
          if s.status notin {PayloadExecutionStatus.syncing, PayloadExecutionStatus.accepted}:
            error "newPayloadV1 status expect syncing or accepted", get=s.status
            return false

          if s.latestValidHash.isSome:
            error "newPayloadV1 latestValidHash not empty"
            return false
        else:
          if s.status != PayloadExecutionStatus.invalid:
            error "newPayloadV1 status expect invalid", get=s.status
            return false

          if s.latestValidHash.isNone:
            return false

          let latestValidHash = s.latestValidHash.get
          if latestValidHash != alteredPayload.parentHash:
            error "latestValidHash is not the same with parentHash",
              expected = alteredPayload.parentHash, get = latestValidHash
            return false

        # Send the forkchoiceUpdated with a reference to the invalid payload.
        let fcState = ForkchoiceStateV1(
          headBlockHash:      alteredPayload.blockHash,
          safeBlockHash:      alteredPayload.blockHash,
          finalizedBlockHash: alteredPayload.blockHash,
        )

        let timestamp = Quantity(alteredPayload.timestamp.int64 + 1)
        let payloadAttr = PayloadAttributesV1(timestamp: timestamp)

        # Execution specification:
        #  {payloadStatus: {status: INVALID, latestValidHash: null, validationError: errorMessage | null}, payloadId: null}
        #  obtained from the Payload validation process if the payload is deemed INVALID
        let rs = client.forkchoiceUpdatedV1(fcState, some(payloadAttr))
        # Execution specification:
        #  {payloadStatus: {status: INVALID, latestValidHash: null, validationError: errorMessage | null}, payloadId: null}
        #  obtained from the Payload validation process if the payload is deemed INVALID
        # Note: SYNCING/ACCEPTED is acceptable here as long as the block produced after this test is produced successfully
        if rs.isErr:
          error "unable to send altered payload", msg=rs.error
          return false

        let z = rs.get()
        if z.payloadStatus.status notin {PayloadExecutionStatus.syncing, PayloadExecutionStatus.accepted, PayloadExecutionStatus.invalid}:
          return false

        # Finally, attempt to fetch the invalid payload using the JSON-RPC endpoint
        var header: rpc_types.BlockHeader
        let rp = client.headerByHash(alteredPayload.blockHash.hash256, header)
        rp.isErr
    ))

    testCond pbRes

    # Lastly, attempt to build on top of the invalid payload
    let psb = clMock.produceSingleBlock(BlockProcessCallbacks(
      # Run test after the new payload has been obtained
      onGetPayload: proc(): bool =
        let alteredPayload = customizePayload(clMock.latestPayloadBuilt.toExecutableData, CustomPayload(
          parentHash: some(invalidPayload.hash),
        ))

        info "Sending customized NewPayload: ParentHash",
          fromHash=clMock.latestPayloadBuilt.parentHash, toHash=invalidPayload.hash
        # Response status can be ACCEPTED (since parent payload could have been thrown out by the client)
        # or SYNCING (parent payload is thrown out and also client assumes that the parent is part of canonical chain)
        # or INVALID (client still has the payload and can verify that this payload is incorrectly building on top of it),
        # but a VALID response is incorrect.
        let rr = client.newPayloadV1(alteredPayload)
        if rr.isErr:
          error "unable to send altered payload", msg=rr.error
          return false

        let z = rr.get()
        z.status in {PayloadExecutionStatus.syncing, PayloadExecutionStatus.accepted, PayloadExecutionStatus.invalid}
    ))

    testCond psb

invalidPayloadTestCaseGen(invalidPayload1, InvalidParentHash)
invalidPayloadTestCaseGen(invalidPayload2, InvalidStateRoot)
invalidPayloadTestCaseGen(invalidPayload3, InvalidStateRoot, true)
invalidPayloadTestCaseGen(invalidPayload4, InvalidReceiptsRoot)
invalidPayloadTestCaseGen(invalidPayload5, InvalidNumber)
invalidPayloadTestCaseGen(invalidPayload6, InvalidGasLimit)
invalidPayloadTestCaseGen(invalidPayload7, InvalidGasUsed)
invalidPayloadTestCaseGen(invalidPayload8, InvalidTimestamp)
invalidPayloadTestCaseGen(invalidPayload9, InvalidPrevRandao)
invalidPayloadTestCaseGen(invalidPayload10, RemoveTransaction)
invalidPayloadTestCaseGen(invalidPayload11, InvalidTransactionSignature)
invalidPayloadTestCaseGen(invalidPayload12, InvalidTransactionNonce)
invalidPayloadTestCaseGen(invalidPayload13, InvalidTransactionGasPrice)
invalidPayloadTestCaseGen(invalidPayload14, InvalidTransactionGas)
invalidPayloadTestCaseGen(invalidPayload15, InvalidTransactionValue)

# Test to verify Block information available at the Eth RPC after NewPayload
template blockStatusExecPayloadGen(procname: untyped, transitionBlock: bool) =
  proc procName(t: TestEnv): TestStatus =
    result = TestStatus.OK

    # Wait until TTD is reached by this client
    let ok = waitFor t.clMock.waitForTTD()
    testCond ok

    # Produce blocks before starting the test, only if we are not testing the transition block
    when not transitionBlock:
      let produce5BlockRes = t.clMock.produceBlocks(5, BlockProcessCallbacks())
      testCond produce5BlockRes

    let clMock = t.clMock
    let client = t.rpcClient
    let shadow = Shadow()

    var produceSingleBlockRes = clMock.produceSingleBlock(BlockProcessCallbacks(
      onPayloadProducerSelected: proc(): bool =
        var address: EthAddress
        testCond t.sendTx(address, 1.u256)
        shadow.hash = rlpHash(t.tx)
        return true
      ,
      onNewPayloadBroadcast: proc(): bool =
        testLatestHeader(client, clMock.latestForkchoice.headBlockHash)

        let nRes = client.blockNumber()
        if nRes.isErr:
          error "Unable to get latest block number", msg=nRes.error
          return false

        # Latest block number available via Eth RPC should not have changed at this point
        let latestNumber = nRes.get
        if latestNumber != clMock.latestHeadNumber:
          error "latest block number incorrect after newPayload",
            expected=clMock.latestHeadNumber,
            get=latestNumber
          return false

        # Check that the receipt for the transaction we just sent is still not available
        let rr = client.txReceipt(shadow.hash)
        if rr.isOk:
          error "not expecting receipt"
          return false

        return true
    ))
    testCond produceSingleBlockRes

blockStatusExecPayloadGen(blockStatusExecPayload1, false)
blockStatusExecPayloadGen(blockStatusExecPayload2, true)

type
  MissingAncestorShadow = ref object
    cA: ExecutionPayloadV1
    n: int
    altChainPayloads: seq[ExecutionPayloadV1]

# Attempt to re-org to a chain which at some point contains an unknown payload which is also invalid.
# Then reveal the invalid payload and expect that the client rejects it and rejects forkchoice updated calls to this chain.
# The invalid_index parameter determines how many payloads apart is the common ancestor from the block that invalidates the chain,
# with a value of 1 meaning that the immediate payload after the common ancestor will be invalid.
template invalidMissingAncestorReOrgGen(procName: untyped,
  invalid_index: int, payloadField: InvalidPayloadField, p2psync: bool, emptyTxs: bool) =

  proc procName(t: TestEnv): TestStatus =
    result = TestStatus.OK

    # Wait until TTD is reached by this client
    let ok = waitFor t.clMock.waitForTTD()
    testCond ok

    let clMock = t.clMock
    let client = t.rpcClient

    # Produce blocks before starting the test
    testCond clMock.produceBlocks(5, BlockProcessCallbacks())

    let shadow = MissingAncestorShadow(
      # Save the common ancestor
      cA: clMock.latestPayloadBuilt,

      # Amount of blocks to deviate starting from the common ancestor
      n: 10,

      # Slice to save the alternate B chain
      altChainPayloads: @[]
    )

    # Append the common ancestor
    shadow.altChainPayloads.add shadow.cA

    # Produce blocks but at the same time create an alternate chain which contains an invalid payload at some point (INV_P)
    # CommonAncestor◄─▲── P1 ◄─ P2 ◄─ P3 ◄─ ... ◄─ Pn
    #                 │
    #                 └── P1' ◄─ P2' ◄─ ... ◄─ INV_P ◄─ ... ◄─ Pn'
    var pbRes = clMock.produceBlocks(shadow.n, BlockProcessCallbacks(
      onPayloadProducerSelected: proc(): bool =
        # Function to send at least one transaction each block produced.
        # Empty Txs Payload with invalid stateRoot discovered an issue in geth sync, hence this is customizable.
        when not emptyTxs:
          # Send the transaction to the prevRandaoContractAddr
          t.sendTx(1.u256)
        return true
      ,
      onGetPayload: proc(): bool =
        # Insert extraData to ensure we deviate from the main payload, which contains empty extradata
        var alternatePayload = customizePayload(clMock.latestPayloadBuilt, CustomPayload(
          parentHash: some(shadow.altChainPayloads[^1].blockHash.hash256),
          extraData:  some(@[1.byte]),
        ))

        if shadow.altChainPayloads.len == invalid_index:
          alternatePayload = generateInvalidPayload(alternatePayload, payloadField)

        shadow.altChainPayloads.add alternatePayload
        return true
    ))
    testCond pbRes

    pbRes = clMock.produceSingleBlock(BlockProcessCallbacks(
      # Note: We perform the test in the middle of payload creation by the CL Mock, in order to be able to
      # re-org back into this chain and use the new payload without issues.
      onGetPayload: proc(): bool =
        # Now let's send the alternate chain to the client using newPayload/sync
        for i in 1..shadow.n:
          # Send the payload
          var payloadValidStr = "VALID"
          if i == invalid_index:
            payloadValidStr = "INVALID"
          elif i > invalid_index:
            payloadValidStr = "VALID with INVALID ancestor"

          info "Invalid chain payload",
            i = i,
            payloadValidStr = payloadValidStr,
            hash = shadow.altChainPayloads[i].blockHash

          let rr = client.newPayloadV1(shadow.altChainPayloads[i])
          testCond rr.isOk

          let rs = client.forkchoiceUpdatedV1(ForkchoiceStateV1(
            headBlockHash: shadow.altChainPayloads[i].blockHash,
            safeBlockHash: shadow.altChainPayloads[i].blockHash
          ))

          if i == invalid_index:
            # If this is the first payload after the common ancestor, and this is the payload we invalidated,
            # then we have all the information to determine that this payload is invalid.
            testNP(rr, invalid, some(shadow.altChainPayloads[i-1].blockHash.hash256))
          elif i > invalid_index:
            # We have already sent the invalid payload, but the client could've discarded it.
            # In reality the CL will not get to this point because it will have already received the `INVALID`
            # response from the previous payload.
            let cond = {PayloadExecutionStatus.accepted, PayloadExecutionStatus.syncing, PayloadExecutionStatus.invalid}
            testNPEither(rr, cond)
          else:
            # This is one of the payloads before the invalid one, therefore is valid.
            let latestValidHash = some(shadow.altChainPayloads[i].blockHash.hash256)
            testNP(rr, valid, latestValidHash)
            testFCU(rs, valid, latestValidHash)


        # Resend the latest correct fcU
        let rx = client.forkchoiceUpdatedV1(clMock.latestForkchoice)
        testCond rx.isOk:
          error "Unexpected error ", msg=rx.error

        # After this point, the CL Mock will send the next payload of the canonical chain
        return true
    ))

    testCond pbRes

invalidMissingAncestorReOrgGen(invalidMissingAncestor1, 1, InvalidStateRoot, false, true)
invalidMissingAncestorReOrgGen(invalidMissingAncestor2, 9, InvalidStateRoot, false, true)
invalidMissingAncestorReOrgGen(invalidMissingAncestor3, 10, InvalidStateRoot, false, true)

template blockStatusHeadBlockGen(procname: untyped, transitionBlock: bool) =
  proc procName(t: TestEnv): TestStatus =
    result = TestStatus.OK

    # Wait until TTD is reached by this client
    let ok = waitFor t.clMock.waitForTTD()
    testCond ok

    # Produce blocks before starting the test, only if we are not testing the transition block
    when not transitionBlock:
      let produce5BlockRes = t.clMock.produceBlocks(5, BlockProcessCallbacks())
      testCond produce5BlockRes

    let clMock = t.clMock
    let client = t.rpcClient
    let shadow = Shadow()

    var produceSingleBlockRes = clMock.produceSingleBlock(BlockProcessCallbacks(
      onPayloadProducerSelected: proc(): bool =
        var address: EthAddress
        testCond t.sendTx(address, 1.u256)
        shadow.hash = rlpHash(t.tx)
        return true
      ,
      # Run test after a forkchoice with new HeadBlockHash has been broadcasted
      onForkchoiceBroadcast: proc(): bool =
        testLatestHeader(client, clMock.latestForkchoice.headBlockHash)

        let rr = client.txReceipt(shadow.hash)
        if rr.isErr:
          error "unable to get transaction receipt"
          return false

        return true
    ))
    testCond produceSingleBlockRes

blockStatusHeadBlockGen(blockStatusHeadBlock1, false)
blockStatusHeadBlockGen(blockStatusHeadBlock2, true)

proc blockStatusSafeBlock(t: TestEnv): TestStatus =
  result = TestStatus.OK

  let clMock = t.clMock
  let client = t.rpcClient

  # On PoW mode, `safe` tag shall return error.
  var header: EthBlockHeader
  var rr = client.namedHeader("safe", header)
  testCond rr.isErr

  # Wait until this client catches up with latest PoS Block
  let ok = waitFor t.clMock.waitForTTD()
  testCond ok

  # First ForkchoiceUpdated sent was equal to 0x00..00, `safe` should return error now
  rr = client.namedHeader("safe", header)
  testCond rr.isErr

  let pbres = clMock.produceBlocks(3, BlockProcessCallbacks(
    # Run test after a forkchoice with new SafeBlockHash has been broadcasted
    onSafeBlockChange: proc(): bool =
      var header: EthBlockHeader
      let rr = client.namedHeader("safe", header)
      testCond rr.isOk
      let safeBlockHash = hash256(clMock.latestForkchoice.safeBlockHash)
      header.blockHash == safeBlockHash
  ))

  testCond pbres

proc blockStatusFinalizedBlock(t: TestEnv): TestStatus =
  result = TestStatus.OK

  let clMock = t.clMock
  let client = t.rpcClient

  # On PoW mode, `finalized` tag shall return error.
  var header: EthBlockHeader
  var rr = client.namedHeader("finalized", header)
  testCond rr.isErr

  # Wait until this client catches up with latest PoS Block
  let ok = waitFor t.clMock.waitForTTD()
  testCond ok

  # First ForkchoiceUpdated sent was equal to 0x00..00, `finalized` should return error now
  rr = client.namedHeader("finalized", header)
  testCond rr.isErr

  let pbres = clMock.produceBlocks(3, BlockProcessCallbacks(
    # Run test after a forkchoice with new FinalizedBlockHash has been broadcasted
    onFinalizedBlockChange: proc(): bool =
      var header: EthBlockHeader
      let rr = client.namedHeader("finalized", header)
      testCond rr.isOk
      let finalizedBlockHash = hash256(clMock.latestForkchoice.finalizedBlockHash)
      header.blockHash == finalizedBlockHash
  ))

  testCond pbres

proc blockStatusReorg(t: TestEnv): TestStatus =
  result = TestStatus.OK

  # Wait until TTD is reached by this client
  let ok = waitFor t.clMock.waitForTTD()
  testCond ok

  # Produce blocks before starting the test
  let produce5BlockRes = t.clMock.produceBlocks(5, BlockProcessCallbacks())
  testCond produce5BlockRes

  let clMock = t.clMock
  let client = t.rpcClient
  var produceSingleBlockRes = clMock.produceSingleBlock(BlockProcessCallbacks(
    # Run test after a forkchoice with new HeadBlockHash has been broadcasted
    onForkchoiceBroadcast: proc(): bool =
      # Verify the client is serving the latest HeadBlock
      var currHeader: EthBlockHeader
      var hRes = client.latestHeader(currHeader)
      if hRes.isErr:
        error "unable to get latest header", msg=hRes.error
        return false

      var currHash = BlockHash currHeader.blockHash.data
      if currHash != clMock.latestForkchoice.headBlockHash or
         currHash == clMock.latestForkchoice.safeBlockHash or
         currHash == clMock.latestForkchoice.finalizedBlockHash:
        error "latest block header doesn't match HeadBlock hash", hash=currHash
        return false

      # Reorg back to the previous block (FinalizedBlock)
      let reorgForkchoice = ForkchoiceStateV1(
        headBlockHash:      clMock.latestForkchoice.finalizedBlockHash,
        safeBlockHash:      clMock.latestForkchoice.finalizedBlockHash,
        finalizedBlockHash: clMock.latestForkchoice.finalizedBlockHash
      )

      var res = client.forkchoiceUpdatedV1(reorgForkchoice)
      if res.isErr:
        error "Could not send forkchoiceUpdatedV1", msg=res.error
        return false

      var s = res.get()
      if s.payloadStatus.status != PayloadExecutionStatus.valid:
        error "Incorrect status returned after a HeadBlockHash reorg", status=s.payloadStatus.status
        return false

      if s.payloadStatus.latestValidHash.isNone:
        error "Cannot get latestValidHash from payloadStatus"
        return false

      var latestValidHash = s.payloadStatus.latestValidHash.get
      if latestValidHash != reorgForkchoice.headBlockHash:
        error "Incorrect latestValidHash returned after a HeadBlockHash reorg",
          expected=reorgForkchoice.headBlockHash,
          get=latestValidHash
        return false

      # testCond that we reorg to the previous block
      testLatestHeader(client, reorgForkchoice.headBlockHash)

      # Send the HeadBlock again to leave everything back the way it was
      res = client.forkchoiceUpdatedV1(clMock.latestForkchoice)
      if res.isErr:
        error "Could not send forkchoiceUpdatedV1", msg=res.error
        return false

      s = res.get()
      if s.payloadStatus.status != PayloadExecutionStatus.valid:
        error "Incorrect status returned after a HeadBlockHash reorg",
          status=s.payloadStatus.status
        return false

      if s.payloadStatus.latestValidHash.isNone:
        error "Cannot get latestValidHash from payloadStatus"
        return false

      latestValidHash = s.payloadStatus.latestValidHash.get
      if latestValidHash != clMock.latestForkchoice.headBlockHash:
        error "Incorrect latestValidHash returned after a HeadBlockHash reorg",
          expected=clMock.latestForkchoice.headBlockHash,
          get=latestValidHash
        return false
      return true
  ))
  testCond produceSingleBlockRes

proc reExecPayloads(t: TestEnv): TestStatus =
  result = TestStatus.OK

  # Wait until this client catches up with latest PoS
  let ok = waitFor t.clMock.waitForTTD()
  testCond ok

  # How many Payloads we are going to re-execute
  var payloadReExecCount = 10

  # Create those blocks
  let produceBlockRes = t.clMock.produceBlocks(payloadReExecCount, BlockProcessCallbacks())
  testCond produceBlockRes

  # Re-execute the payloads
  let client = t.rpcClient
  var hRes = client.blockNumber()
  testCond hRes.isOk:
    error "unable to get blockNumber", msg=hRes.error

  let lastBlock = int(hRes.get)
  info "Started re-executing payloads at block", number=lastBlock

  let
    clMock = t.clMock
    start  = lastBlock - payloadReExecCount + 1

  for i in start..lastBlock:
    if clMock.executedPayloadHistory.hasKey(uint64 i):
      let payload = clMock.executedPayloadHistory[uint64 i]
      let res = client.newPayloadV1(payload)
      testCond res.isOk:
        error "FAIL (%s): Unable to re-execute valid payload", msg=res.error

      let s = res.get()
      testCond s.status == PayloadExecutionStatus.valid:
        error "Unexpected status after re-execute valid payload", status=s.status
    else:
      testCond true:
        error "(test issue) Payload does not exist", index=i

proc multipleNewCanonicalPayloads(t: TestEnv): TestStatus =
  result = TestStatus.OK

  # Wait until TTD is reached by this client
  let ok = waitFor t.clMock.waitForTTD()
  testCond ok

  # Produce blocks before starting the test
  let produce5BlockRes = t.clMock.produceBlocks(5, BlockProcessCallbacks())
  testCond produce5BlockRes

  let clMock = t.clMock
  let client = t.rpcClient
  var produceSingleBlockRes = clMock.produceSingleBlock(BlockProcessCallbacks(
    # Run test after a new payload has been obtained
    onGetPayload: proc(): bool =
      let payloadCount = 80
      let basePayload = toExecutableData(clMock.latestPayloadBuilt)
      var newPrevRandao: Hash256

      # Fabricate and send multiple new payloads by changing the PrevRandao field
      for i in 0..<payloadCount:
        doAssert randomBytes(newPrevRandao.data) == 32
        let newPayload = customizePayload(basePayload, CustomPayload(
          prevRandao: some(newPrevRandao)
        ))

        let res = client.newPayloadV1(newPayload)
        if res.isErr:
          error "Unable to send new valid payload extending canonical chain", msg=res.error
          return false

        let s = res.get()
        if s.status != PayloadExecutionStatus.valid:
          error "Unexpected status after trying to send new valid payload extending canonical chain",
            status=s.status
          return false
      return true
  ))
  # At the end the clMocker continues to try to execute fcU with the original payload, which should not fail
  testCond produceSingleBlockRes

proc outOfOrderPayloads(t: TestEnv): TestStatus =
  result = TestStatus.OK

  # Wait until TTD is reached by this client
  let ok = waitFor t.clMock.waitForTTD()
  testCond ok

  # First prepare payloads on a first client, which will also contain multiple transactions

  # We will be also verifying that the transactions are correctly interpreted in the canonical chain,
  # prepare a random account to receive funds.
  const
    amountPerTx  = 1000.u256
    txPerPayload = 20
    payloadCount = 10

  var recipient: EthAddress
  doAssert randomBytes(recipient) == 20

  let clMock = t.clMock
  let client = t.rpcClient
  var produceBlockRes = clMock.produceBlocks(payloadCount, BlockProcessCallbacks(
    # We send the transactions after we got the Payload ID, before the clMocker gets the prepared Payload
    onPayloadProducerSelected: proc(): bool =
      for i in 0..<txPerPayload:
        testCond t.sendTx(recipient, amountPerTx)
      return true
  ))
  testCond produceBlockRes

  let expectedBalance = amountPerTx * u256(payloadCount*txPerPayload)

  # testCond balance on this first client
  let balRes = client.balanceAt(recipient)
  testCond balRes.isOk:
    error "Error while getting balance of funded account"

  let bal = balRes.get()
  testCond expectedBalance == bal

  # TODO: this section need multiple client

# Test that performing a re-org back into a previous block of the canonical chain does not produce errors and the chain
# is still capable of progressing.
proc reorgBack(t: TestEnv): TestStatus =
  result = TestStatus.OK

  # Wait until TTD is reached by this client
  let ok = waitFor t.clMock.waitForTTD()
  testCond ok

  let clMock = t.clMock
  let client = t.rpcClient

  testCond clMock.produceSingleBlock(BlockProcessCallbacks())

  # We are going to reorg back to this previous hash several times
  let previousHash = clMock.latestForkchoice.headBlockHash

  # Produce blocks before starting the test (So we don't try to reorg back to the genesis block)
  let r2 = clMock.produceBlocks(5, BlockProcessCallbacks(
    onForkchoiceBroadcast: proc(): bool =
      # Send a fcU with the HeadBlockHash pointing back to the previous block
      let forkchoiceUpdatedBack = ForkchoiceStateV1(
        headBlockHash:      previousHash,
        safeBlockHash:      previousHash,
        finalizedBlockHash: previousHash,
      )

      # It is only expected that the client does not produce an error and the CL Mocker is able to progress after the re-org
      let r = client.forkchoiceUpdatedV1(forkchoiceUpdatedBack)
      testCond r.isOk:
        error "failed to reorg back", msg = r.error
      return true
  ))
  testCond r2

  # Verify that the client is pointing to the latest payload sent
  testLatestHeader(client, clMock.latestPayloadBuilt.blockHash)

# Test that performs a re-org back to the canonical chain after re-org to syncing/unavailable chain.
type
  SideChainList = ref object
    sidechainPayloads: seq[ExecutionPayloadV1]

proc reorgBackFromSyncing(t: TestEnv): TestStatus =
  result = TestStatus.OK

  # Wait until TTD is reached by this client
  let ok = waitFor t.clMock.waitForTTD()
  testCond ok

  # Produce an alternative chain
  let pList = SideChainList()
  let clMock = t.clMock
  let client = t.rpcClient

  let r1 = clMock.produceBlocks(10, BlockProcessCallbacks(
    onGetPayload: proc(): bool =
      # Generate an alternative payload by simply adding extraData to the block
      var altParentHash = clMock.latestPayloadBuilt.parentHash

      if pList.sidechainPayloads.len > 0:
        altParentHash = pList.sidechainPayloads[^1].blockHash

      let executableData = toExecutableData(clMock.latestPayloadBuilt)
      let altPayload = customizePayload(executableData,
        CustomPayload(
          parentHash: some(altParentHash.hash256),
          extraData:  some(@[0x01.byte]),
        ))

      pList.sidechainPayloads.add(altPayload)
      return true
  ))

  testCond r1


  # Produce blocks before starting the test (So we don't try to reorg back to the genesis block)
  let r2= clMock.produceSingleBlock(BlockProcessCallbacks(
    onGetPayload: proc(): bool =
      let r = client.newPayloadV1(pList.sidechainPayloads[^1])
      if r.isErr:
        return false
      let s = r.get()
      if s.status notin {PayloadExecutionStatus.syncing, PayloadExecutionStatus.accepted}:
        return false

      # We are going to send one of the alternative payloads and fcU to it
      let len = pList.sidechainPayloads.len
      let forkchoiceUpdatedBack = ForkchoiceStateV1(
        headBlockHash:      pList.sidechainPayloads[len-1].blockHash,
        safeBlockHash:      pList.sidechainPayloads[len-2].blockHash,
        finalizedBlockHash: pList.sidechainPayloads[len-3].blockHash,
      )

      # It is only expected that the client does not produce an error and the CL Mocker is able to progress after the re-org
      let res = client.forkchoiceUpdatedV1(forkchoiceUpdatedBack)
      if res.isErr:
        return false

      let rs = res.get()
      if rs.payloadStatus.status != PayloadExecutionStatus.syncing:
        return false

      rs.payloadStatus.latestValidHash.isNone
      # After this, the clMocker will continue and try to re-org to canonical chain once again
      # clMocker will fail the test if this is not possible, so nothing left to do.
  ))

  testCond r2

type
  TxReorgShadow = ref object
    noTxnPayload: ExecutionPayloadV1
    txHash: Hash256

proc transactionReorg(t: TestEnv): TestStatus =
  result = TestStatus.OK

  # Wait until TTD is reached by this client
  let ok = waitFor t.clMock.waitForTTD()
  testCond ok

  # Produce blocks before starting the test
  testCond t.clMock.produceBlocks(5, BlockProcessCallbacks())

  # Create transactions that modify the state in order to testCond after the reorg.
  const
    txCount      = 5
    contractAddr = hexToByteArray[20]("0000000000000000000000000000000000000317")

  let
    client = t.rpcClient
    clMock = t.clMock
    shadow = TxReorgShadow()

  for i in 0..<txCount:
    # Generate two payloads, one with the transaction and the other one without it
    let pbres = clMock.produceSingleBlock(BlockProcessCallbacks(
      onPayloadProducerSelected: proc(): bool =
        # At this point we have not broadcast the transaction,
        # therefore any payload we get should not contain any transactions
        if not clMock.getNextPayloadID(): return false
        if not clMock.getNextPayload(): return false

        shadow.noTxnPayload = clMock.latestPayloadBuilt
        if shadow.noTxnPayload.transactions.len != 0:
          error "Empty payload contains transactions"
          return false

        # At this point we can broadcast the transaction and it will be included in the next payload
        # Data is the key where a `1` will be stored
        let data = i.u256
        testCond t.sendTx(contractAddr, 0.u256, data.toBytesBE)
        shadow.txHash = rlpHash(t.tx)

        # Get the receipt
        let rr = client.txReceipt(shadow.txHash)
        if rr.isOk:
          error "Receipt obtained before tx included in block"
          return false
        return true
      ,
      onGetPayload: proc(): bool =
        # Check that indeed the payload contains the transaction
        if not txInPayload(clMock.latestPayloadBuilt, shadow.txHash):
          error "Payload built does not contain the transaction"
          return false
        return true
      ,
      onForkchoiceBroadcast: proc(): bool =
        # Transaction is now in the head of the canonical chain, re-org and verify it's removed
        var rr = client.txReceipt(shadow.txHash)
        if rr.isErr:
          error "Unable to obtain transaction receipt"
          return false

        if shadow.noTxnPayload.parentHash != clMock.latestPayloadBuilt.parentHash:
          error "Incorrect parent hash for payloads",
            get = shadow.noTxnPayload.parentHash,
            expect = clMock.latestPayloadBuilt.parentHash
          return false

        if shadow.noTxnPayload.blockHash == clMock.latestPayloadBuilt.blockHash:
          error "Incorrect hash for payloads",
            get = shadow.noTxnPayload.blockHash,
            expect = clMock.latestPayloadBuilt.blockHash
          return false

        let rz = client.newPayloadV1(shadow.noTxnPayload)
        testNP(rz, valid, some(hash256(shadow.noTxnPayload.blockHash)))

        let rx = client.forkchoiceUpdatedV1(ForkchoiceStateV1(
          headBlockHash:      shadow.noTxnPayload.blockHash,
          safeBlockHash:      clMock.latestForkchoice.safeBlockHash,
          finalizedBlockHash: clMock.latestForkchoice.finalizedBlockHash
        ))
        testFCU(rx, valid)

        testLatestHeader(client, shadow.noTxnPayload.blockHash)

        let rk = client.txReceipt(shadow.txHash)
        if rk.isOk:
          error "Receipt was obtained when the tx had been re-org'd out"
          return false

        # Re-org back
        let ry = clMock.broadcastForkchoiceUpdated(clMock.latestForkchoice)
        ry.isOk
    ))

    testCond pbres

proc testCondPrevRandaoValue(t: TestEnv, expectedPrevRandao: Hash256, blockNumber: uint64): bool =
  let storageKey = blockNumber.u256
  let client = t.rpcClient

  let res = client.storageAt(prevRandaoContractAddr, storageKey)
  if res.isErr:
    error "Unable to get storage", msg=res.error
    return false

  let opcodeValueAtBlock = Hash256(data: res.get().toBytesBE)
  if opcodeValueAtBlock != expectedPrevRandao:
    error "Storage does not match prevRandao",
      expected=expectedPrevRandao.data,
      get=opcodeValueAtBlock
    return false
  true

proc sidechainReorg(t: TestEnv): TestStatus =
  result = TestStatus.OK

  # Wait until TTD is reached by this client
  let ok = waitFor t.clMock.waitForTTD()
  testCond ok

  # Produce blocks before starting the test
  testCond t.clMock.produceBlocks(5, BlockProcessCallbacks())

  let
    client = t.rpcClient
    clMock = t.clMock

  # Produce two payloads, send fcU with first payload, testCond transaction outcome, then reorg, testCond transaction outcome again

  # This single transaction will change its outcome based on the payload
  testCond t.sendTx(0.u256)

  let singleBlockRes = clMock.produceSingleBlock(BlockProcessCallbacks(
    onNewPayloadBroadcast: proc(): bool =
      # At this point the clMocker has a payload that will result in a specific outcome,
      # we can produce an alternative payload, send it, fcU to it, and verify the changes
      var alternativePrevRandao: Hash256
      doAssert randomBytes(alternativePrevRandao.data) == 32

      let timestamp = Quantity toUnix(clMock.latestHeader.timestamp + 1.seconds)
      let payloadAttributes = PayloadAttributesV1(
        timestamp:             timestamp,
        prevRandao:            FixedBytes[32] alternativePrevRandao.data,
        suggestedFeeRecipient: Address clMock.nextFeeRecipient,
      )

      var res = client.forkchoiceUpdatedV1(clMock.latestForkchoice, some(payloadAttributes))
      if res.isErr:
        error "Could not send forkchoiceUpdatedV1", msg=res.error
        return false

      let s = res.get()
      let rr = client.getPayloadV1(s.payloadID.get())
      if rr.isErr:
        error "Could not get alternative payload", msg=rr.error
        return false

      let alternativePayload = rr.get()
      if alternativePayload.transactions.len == 0:
        error "alternative payload does not contain the prevRandao opcode tx"
        return false

      let rx = client.newPayloadV1(alternativePayload)
      if rx.isErr:
        error "Could not send alternative payload", msg=rx.error
        return false

      let alternativePayloadStatus = rx.get()
      if alternativePayloadStatus.status != PayloadExecutionStatus.valid:
        error "Alternative payload response returned Status!=VALID",
          status=alternativePayloadStatus.status
        return false

      # We sent the alternative payload, fcU to it
      let alternativeHeader = toBlockHeader(alternativePayload)
      let rHash = BlockHash alternativeHeader.blockHash.data
      let alternativeFcU = ForkchoiceStateV1(
        headBlockHash:      rHash,
        safeBlockHash:      clMock.latestForkchoice.safeBlockHash,
        finalizedBlockHash: clMock.latestForkchoice.finalizedBlockHash
      )

      res = client.forkchoiceUpdatedV1(alternativeFcU)
      if res.isErr:
        error "Could not send alternative fcU", msg=res.error
        return false

      let alternativeFcUResp = res.get()
      if alternativeFcUResp.payloadStatus.status != PayloadExecutionStatus.valid:
        error "Alternative fcU response returned Status!=VALID",
          status=alternativeFcUResp.payloadStatus.status
        return false

      # PrevRandao should be the alternative prevRandao we sent
      return testCondPrevRandaoValue(t, alternativePrevRandao, uint64 alternativePayload.blockNumber)
  ))

  testCond singleBlockRes
  # The reorg actually happens after the clMocker continues,
  # verify here that the reorg was successful
  let latestBlockNum = clMock.latestHeadNumber.uint64
  testCond testCondPrevRandaoValue(t, clMock.prevRandaoHistory[latestBlockNum], latestBlockNum)

proc suggestedFeeRecipient(t: TestEnv): TestStatus =
  result = TestStatus.OK

  # Wait until TTD is reached by this client
  let ok = waitFor t.clMock.waitForTTD()
  testCond ok

  # Amount of transactions to send
  const
    txCount = 20

  # Verify that, in a block with transactions, fees are accrued by the suggestedFeeRecipient
  var feeRecipient: EthAddress
  testCond randomBytes(feeRecipient) == 20

  let
    client = t.rpcClient
    clMock = t.clMock

  # Send multiple transactions
  for i in 0..<txCount:
    # Empty self tx
    discard t.sendTx(vaultAccountAddr, 0.u256)

  # Produce the next block with the fee recipient set
  clMock.nextFeeRecipient = feeRecipient
  testCond clMock.produceSingleBlock(BlockProcessCallbacks())

  # Calculate the fees and testCond that they match the balance of the fee recipient
  var blockIncluded: EthBlock
  var rr = client.latestBlock(blockIncluded)
  testCond rr.isOk:
    error "unable to get latest block", msg=rr.error

  testCond blockIncluded.txs.len == txCount:
    error "not all transactions were included in block",
      expected=txCount,
      get=blockIncluded.txs.len

  testCond blockIncluded.header.coinbase == feeRecipient:
    error "feeRecipient was not set as coinbase",
      expected=feeRecipient,
      get=blockIncluded.header.coinbase

  var feeRecipientFees = 0.u256
  for tx in blockIncluded.txs:
    let effGasTip = tx.effectiveGasTip(blockIncluded.header.fee)
    let tr = client.txReceipt(rlpHash(tx))
    testCond tr.isOk:
      error "unable to obtain receipt", msg=tr.error

    let rec = tr.get()
    let gasUsed = UInt256.fromHex(rec.gasUsed.string)
    feeRecipientFees = feeRecipientFees  + effGasTip.u256 * gasUsed

  var br = client.balanceAt(feeRecipient)
  testCond br.isOk

  var feeRecipientBalance = br.get()
  testCond feeRecipientBalance == feeRecipientFees:
    error "balance does not match fees",
      feeRecipientBalance, feeRecipientFees

  # Produce another block without txns and get the balance again
  clMock.nextFeeRecipient = feeRecipient
  testCond clMock.produceSingleBlock(BlockProcessCallbacks())

  br = client.balanceAt(feeRecipient)
  testCond br.isOk
  feeRecipientBalance = br.get()
  testCond feeRecipientBalance == feeRecipientFees:
    error "balance does not match fees",
      feeRecipientBalance, feeRecipientFees

proc sendTxAsync(t: TestEnv): Future[void] {.async.} =
  let
    clMock = t.clMock
    period = chronos.milliseconds(500)

  while not clMock.ttdReached:
    await sleepAsync(period)
    discard t.sendTx(0.u256)

proc prevRandaoOpcodeTx(t: TestEnv): TestStatus =
  result = TestStatus.OK

  let
    client = t.rpcClient
    clMock = t.clMock
    sendTxFuture = sendTxAsync(t)

  # Wait until TTD is reached by this client
  let ok = waitFor clMock.waitForTTD()
  testCond ok

  # Ideally all blocks up until TTD must have a DIFFICULTY opcode tx in it
  let nr = client.blockNumber()
  testCond nr.isOk:
    error "Unable to get latest block number", msg=nr.error

  let ttdBlockNumber = nr.get()

  # Start
  for i in ttdBlockNumber..ttdBlockNumber:
    # First testCond that the block actually contained the transaction
    var blk: EthBlock
    let res = client.blockByNumber(i, blk)
    testCond res.isOk:
      error "Unable to get block", msg=res.error

    testCond blk.txs.len > 0:
      error "(Test issue) no transactions went in block"

    let storageKey = i.u256
    let rr = client.storageAt(prevRandaoContractAddr, storageKey)
    testCond rr.isOk:
      error "Unable to get storage", msg=rr.error

    let opcodeValueAtBlock = rr.get()
    testCond opcodeValueAtBlock == 2.u256:
      error "Incorrect difficulty value in block",
        expect=2,
        get=opcodeValueAtBlock

  # Send transactions now past TTD, the value of the storage in these blocks must match the prevRandao value
  type
    ShadowTx = ref object
      currentTxIndex: int
      txs: seq[Transaction]

  let shadow = ShadowTx(currentTxIndex: 0)

  let produceBlockRes = clMock.produceBlocks(10, BlockProcessCallbacks(
    onPayloadProducerSelected: proc(): bool =
      testCond t.sendTx(0.u256)
      shadow.txs.add t.tx
      inc shadow.currentTxIndex
      return true
    ,
    onForkchoiceBroadcast: proc(): bool =
      # Check the transaction tracing, which is client specific
      let expectedPrevRandao = clMock.prevRandaoHistory[clMock.latestHeadNumber + 1'u64]
      let res = debugPrevRandaoTransaction(client, shadow.txs[shadow.currentTxIndex-1], expectedPrevRandao)
      if res.isErr:
        error "unable to debug prev randao", msg=res.error
        return false
      return true
  ))

  testCond produceBlockRes

  let rr = client.blockNumber()
  testCond rr.isOk:
    error "Unable to get latest block number"

  let lastBlockNumber = rr.get()
  for i in ttdBlockNumber + 1 ..< lastBlockNumber:
    let expectedPrevRandao = UInt256.fromBytesBE(clMock.prevRandaoHistory[i].data)
    let storageKey = i.u256

    let rz = client.storageAt(prevRandaoContractAddr, storageKey)
    testCond rz.isOk:
      error "Unable to get storage", msg=rz.error

    let storage = rz.get()
    testCond storage == expectedPrevRandao:
      error "Unexpected storage", expected=expectedPrevRandao, get=storage

proc postMergeSync(t: TestEnv): TestStatus =
  result = TestStatus.SKIPPED
  # TODO: need multiple client

const engineTestList* = [
  # Engine API Negative Test Cases
  TestSpec(
    name: "Invalid Terminal Block in ForkchoiceUpdated",
    run: invalidTerminalBlockForkchoiceUpdated,
    ttd: 1000000
  ),
  TestSpec(
    name: "Invalid GetPayload Under PoW",
    run: invalidGetPayloadUnderPoW,
    ttd: 1000000
  ),
  TestSpec(
    name: "Invalid Terminal Block in NewPayload",
    run:  invalidTerminalBlockNewPayload,
    ttd:  1000000,
  ),
  TestSpec(
    name: "Inconsistent Head in ForkchoiceState",
    run:  inconsistentForkchoiceState1,
  ),
  TestSpec(
    name: "Inconsistent Safe in ForkchoiceState",
    run:  inconsistentForkchoiceState2,
  ),
  TestSpec(
    name: "Inconsistent Finalized in ForkchoiceState",
    run:  inconsistentForkchoiceState3,
  ),
  TestSpec(
    name: "Unknown HeadBlockHash",
    run:  unknownHeadBlockHash,
  ),
  TestSpec(
    name: "Unknown SafeBlockHash",
    run:  unknownSafeBlockHash,
  ),
  TestSpec(
    name: "Unknown FinalizedBlockHash",
    run:  unknownFinalizedBlockHash,
  ),
  TestSpec(
    name: "ForkchoiceUpdated Invalid Payload Attributes",
    run:  invalidPayloadAttributes1,
  ),
  TestSpec(
    name: "ForkchoiceUpdated Invalid Payload Attributes (Syncing)",
    run:  invalidPayloadAttributes2,
  ),
  TestSpec(
    name: "Pre-TTD ForkchoiceUpdated After PoS Switch",
    run:  preTTDFinalizedBlockHash,
    ttd:  2,
  ),
  # Invalid Payload Tests
  TestSpec(
    name: "Bad Hash on NewPayload",
    run:  badHashOnNewPayload1,
  ),
  TestSpec(
    name: "Bad Hash on NewPayload Syncing",
    run:  badHashOnNewPayload2,
  ),
  TestSpec(
    name: "Bad Hash on NewPayload Side Chain",
    run:  badHashOnNewPayload3,
  ),
  TestSpec(
    name: "Bad Hash on NewPayload Side Chain Syncing",
    run:  badHashOnNewPayload4,
  ),
  TestSpec(
    name: "ParentHash==BlockHash on NewPayload",
    run:  parentHashOnExecPayload,
  ),
  TestSpec(
    name: "Invalid Transition Payload",
    run: invalidTransitionPayload,
    ttd: 393504,
    chainFile: "blocks_2_td_393504.rlp",
  ),
  TestSpec(
    name: "Invalid ParentHash NewPayload",
    run:  invalidPayload1,
  ),
  TestSpec(
    name: "Invalid StateRoot NewPayload",
    run:  invalidPayload2,
  ),
  TestSpec(
    name: "Invalid StateRoot NewPayload, Empty Transactions",
    run:  invalidPayload3,
  ),
  TestSpec(
    name: "Invalid ReceiptsRoot NewPayload",
    run:  invalidPayload4,
  ),
  TestSpec(
    name: "Invalid Number NewPayload",
    run:  invalidPayload5,
  ),
  TestSpec(
    name: "Invalid GasLimit NewPayload",
    run:  invalidPayload6,
  ),
  TestSpec(
    name: "Invalid GasUsed NewPayload",
    run:  invalidPayload7,
  ),
  TestSpec(
    name: "Invalid Timestamp NewPayload",
    run:  invalidPayload8,
  ),
  TestSpec(
    name: "Invalid PrevRandao NewPayload",
    run:  invalidPayload9,
  ),
  TestSpec(
    name: "Invalid Incomplete Transactions NewPayload",
    run:  invalidPayload10,
  ),
  TestSpec(
    name: "Invalid Transaction Signature NewPayload",
    run:  invalidPayload11,
  ),
  TestSpec(
    name: "Invalid Transaction Nonce NewPayload",
    run:  invalidPayload12,
  ),
  TestSpec(
    name: "Invalid Transaction GasPrice NewPayload",
    run:  invalidPayload13,
  ),
  TestSpec(
    name: "Invalid Transaction Gas NewPayload",
    run:  invalidPayload14,
  ),
  TestSpec(
    name: "Invalid Transaction Value NewPayload",
    run:  invalidPayload15,
  ),

  # Invalid Ancestor Re-Org Tests (Reveal via newPayload)
  TestSpec(
    name: "Invalid Ancestor Chain Re-Org, Invalid StateRoot, Invalid P1', Reveal using newPayload",
    slotsToFinalized: 20,
    run:  invalidMissingAncestor1,
  ),
  TestSpec(
    name: "Invalid Ancestor Chain Re-Org, Invalid StateRoot, Invalid P9', Reveal using newPayload",
    slotsToFinalized: 20,
    run:  invalidMissingAncestor2,
  ),
  TestSpec(
    name: "Invalid Ancestor Chain Re-Org, Invalid StateRoot, Invalid P10', Reveal using newPayload",
    slotsToFinalized: 20,
    run:  invalidMissingAncestor3,
  ),

  # Eth RPC Status on ForkchoiceUpdated Events
  TestSpec(
    name: "Latest Block after NewPayload",
    run:  blockStatusExecPayload1,
  ),
  TestSpec(
    name: "Latest Block after NewPayload (Transition Block)",
    run:  blockStatusExecPayload2,
    ttd:  5,
  ),
  TestSpec(
    name: "Latest Block after New HeadBlock",
    run:  blockStatusHeadBlock1,
  ),
  TestSpec(
    name: "Latest Block after New HeadBlock (Transition Block)",
    run:  blockStatusHeadBlock2,
    ttd:  5,
  ),
  TestSpec(
    name: "safe Block after New SafeBlockHash",
    run:  blockStatusSafeBlock,
    ttd:  5,
  ),
  TestSpec(
    name: "finalized Block after New FinalizedBlockHash",
    run:  blockStatusFinalizedBlock,
    ttd:  5,
  ),
  TestSpec(
    name: "Latest Block after Reorg",
    run:  blockStatusReorg,
  ),

  # Payload Tests
  TestSpec(
    name: "Re-Execute Payload",
    run:  reExecPayloads,
  ),
  TestSpec(
    name: "Multiple New Payloads Extending Canonical Chain",
    run:  multipleNewCanonicalPayloads,
  ),
  TestSpec(
    name: "Out of Order Payload Execution",
    run:  outOfOrderPayloads,
  ),

  # Transaction Reorg using Engine API
  TestSpec(
    name: "Transaction Reorg",
    run:  transactionReorg,
  ),
  TestSpec(
    name: "Sidechain Reorg",
    run:  sidechainReorg,
  ),
  TestSpec(
    name: "Re-Org Back into Canonical Chain",
    run:  reorgBack,
  ),
  TestSpec(
    name: "Re-Org Back to Canonical Chain From Syncing Chain",
    run:  reorgBackFromSyncing,
  ),

  # Suggested Fee Recipient in Payload creation
  TestSpec(
    name: "Suggested Fee Recipient Test",
    run:  suggestedFeeRecipient,
  ),

  # PrevRandao opcode tests
  TestSpec(
    name: "PrevRandao Opcode Transactions",
    run:  prevRandaoOpcodeTx,
    ttd:  10,
  ),

  # Multi-Client Sync tests
  TestSpec(
    name: "Sync Client Post Merge",
    run:  postMergeSync,
    ttd:  10,
  )
]