# beacon_chain
# Copyright (c) 2018-2021 Status Research & Development GmbH
# Licensed and distributed under either of
#   * MIT license (license terms in the root directory or at https://opensource.org/licenses/MIT).
#   * Apache v2 license (license terms in the root directory or at https://www.apache.org/licenses/LICENSE-2.0).
# at your option. This file may not be copied, modified, or distributed except according to those terms.

{.push raises: [Defect].}

import
  std/[parseutils, sequtils, strutils, sets],
  stew/[byteutils, results],
  json_rpc/servers/httpserver,
  chronicles,
  ../beacon_node,
  ../networking/eth2_network,
  ../validators/validator_duties,
  ../consensus_object_pools/blockchain_dag,
  ../spec/[eth2_merkleization, forks, network, validator],
  ../spec/datatypes/[phase0],
  ./rpc_utils

logScope: topics = "beaconapi"

type
  RpcServer = RpcHttpServer

  ValidatorQuery = object
    # Security note / threat model:
    # - The validator pubkey are stored in their raw bytes representation
    #   in the `keyset`.
    # - While the input is from unknown source (as far as the beacon node is concerned),
    #   users are asked to not expose their
    #   RPC endpoints to untrusted network or use a reverse proxy in front.
    # - At usage time, keys in the keyset are compared to keys registered
    #   in the Ethereum BeaconState which are valid
    keyset: HashSet[ValidatorPubKey]
    ids: seq[uint64]

  StatusQuery = object
    statset: HashSet[string]

template unimplemented() =
  raise (ref CatchableError)(msg: "Unimplemented")

proc createIdQuery(ids: openArray[string]): Result[ValidatorQuery, cstring] =
  # validatorIds array should have maximum 30 items, and all items should be
  # unique.
  if len(ids) > 30:
    return err("The number of ids exceeds the limit")

  # All ids in validatorIds must be unique.
  if len(ids) != len(toHashSet(ids)):
    return err("ids array must have unique item")

  var res = ValidatorQuery(
    keyset: initHashSet[ValidatorPubKey](),
    ids: newSeq[uint64]()
  )

  for item in ids:
    if item.startsWith("0x"):
      let pubkey = ? ValidatorPubKey.fromHex(item)
      res.keyset.incl(pubkey)
    else:
      var tmp: uint64
      try:
        if parseBiggestUInt(item, tmp) != len(item):
          return err("Incorrect index value")
      except ValueError:
        return err("Cannot parse index value")
      res.ids.add(tmp)
  ok(res)

proc createStatusQuery(status: openArray[string]): Result[StatusQuery, string] =
  const AllowedStatuses = [
    "pending", "pending_initialized", "pending_queued",
    "active", "active_ongoing", "active_exiting", "active_slashed",
    "exited", "exited_unslashed", "exited_slashed",
    "withdrawal", "withdrawal_possible", "withdrawal_done"
  ]

  if len(status) > len(AllowedStatuses):
    return err("The number of statuses exceeds the limit")

  var res = StatusQuery(statset: initHashSet[string]())

  # All ids in validatorIds must be unique.
  if len(status) != len(toHashSet(status)):
    return err("Status array must have unique items")

  for item in status:
    if item notin AllowedStatuses:
      return err("Invalid status requested")
    case item
    of "pending":
      res.statset.incl("pending_initialized")
      res.statset.incl("pending_queued")
    of "active":
      res.statset.incl("active_ongoing")
      res.statset.incl("active_exiting")
      res.statset.incl("active_slashed")
    of "exited":
      res.statset.incl("exited_unslashed")
      res.statset.incl("exited_slashed")
    of "withdrawal":
      res.statset.incl("withdrawal_possible")
      res.statset.incl("withdrawal_done")
    else:
      res.statset.incl(item)

proc getStatus(validator: Validator,
               current_epoch: Epoch): Result[string, string] =
  if validator.activation_epoch > current_epoch:
    # pending
    if validator.activation_eligibility_epoch == FAR_FUTURE_EPOCH:
      ok("pending_initialized")
    else:
      # validator.activation_eligibility_epoch < FAR_FUTURE_EPOCH:
      ok("pending_queued")
  elif (validator.activation_epoch <= current_epoch) and
       (current_epoch < validator.exit_epoch):
    # active
    if validator.exit_epoch == FAR_FUTURE_EPOCH:
      ok("active_ongoing")
    elif not validator.slashed:
      # validator.exit_epoch < FAR_FUTURE_EPOCH
      ok("active_exiting")
    else:
      # validator.exit_epoch < FAR_FUTURE_EPOCH and validator.slashed:
      ok("active_slashed")
  elif (validator.exit_epoch <= current_epoch) and
       (current_epoch < validator.withdrawable_epoch):
    # exited
    if not validator.slashed:
      ok("exited_unslashed")
    else:
      # validator.slashed
      ok("exited_slashed")
  elif validator.withdrawable_epoch <= current_epoch:
    # withdrawal
    if validator.effective_balance != 0:
      ok("withdrawal_possible")
    else:
      # validator.effective_balance == 0
      ok("withdrawal_done")
  else:
    err("Invalid validator status")

proc getForkedBlockFromBlockId(
    node: BeaconNode, blockId: string): ForkedTrustedSignedBeaconBlock {.
    raises: [Defect, CatchableError].} =
  case blockId:
    of "head":
      node.dag.getForkedBlock(node.dag.head.bid).valueOr:
        raise newException(CatchableError, "Block not found")
    of "genesis":
      node.dag.getForkedBlock(node.dag.genesis).valueOr:
        raise newException(CatchableError, "Block not found")
    of "finalized":
      node.dag.getForkedBlock(node.dag.finalizedHead.blck.bid).valueOr:
        raise newException(CatchableError, "Block not found")
    else:
      if blockId.startsWith("0x"):
        let
          blckRoot = parseRoot(blockId)
        node.dag.getForkedBlock(blckRoot).valueOr:
          raise newException(CatchableError, "Block not found")
      else:
        let bid = node.getBlockIdFromString(blockId)
        node.dag.getForkedBlock(bid).valueOr:
          raise newException(CatchableError, "Block not found")

proc installBeaconApiHandlers*(rpcServer: RpcServer, node: BeaconNode) {.
    raises: [Defect, CatchableError].} =
  rpcServer.rpc("get_v1_beacon_genesis") do () -> RpcBeaconGenesis:
    return (
      genesis_time: getStateField(node.dag.headState, genesis_time),
      genesis_validators_root:
        getStateField(node.dag.headState, genesis_validators_root),
      genesis_fork_version: node.dag.cfg.GENESIS_FORK_VERSION
    )

  rpcServer.rpc("get_v1_beacon_states_root") do (stateId: string) -> Eth2Digest:
    withStateForStateId(stateId):
      return stateRoot

  rpcServer.rpc("get_v1_beacon_states_fork") do (stateId: string) -> Fork:
    withStateForStateId(stateId):
      return getStateField(state, fork)

  rpcServer.rpc("get_v1_beacon_states_finality_checkpoints") do (
      stateId: string) -> RpcBeaconStatesFinalityCheckpoints:
    withStateForStateId(stateId):
      return (previous_justified:
                getStateField(state, previous_justified_checkpoint),
              current_justified:
                getStateField(state, current_justified_checkpoint),
              finalized: getStateField(state, finalized_checkpoint))

  rpcServer.rpc("get_v1_beacon_states_stateId_validators") do (
      stateId: string, validatorIds: Option[seq[string]],
      status: Option[seq[string]]) -> seq[RpcBeaconStatesValidators]:
    var vquery: ValidatorQuery
    var squery: StatusQuery
    let current_epoch = getStateField(node.dag.headState, slot).epoch

    template statusCheck(status, statusQuery, vstatus, current_epoch): bool =
      if status.isNone():
        true
      else:
        if vstatus in squery.statset:
          true
        else:
          false

    var res: seq[RpcBeaconStatesValidators]

    withStateForStateId(stateId):
      if status.isSome:
        let sqres = createStatusQuery(status.get())
        if sqres.isErr:
          raise newException(CatchableError, sqres.error)
        squery = sqres.get()

      if validatorIds.isSome:
        let vqres = createIdQuery(validatorIds.get())
        if vqres.isErr:
          raise newException(CatchableError, $vqres.error)
        vquery = vqres.get()

      if validatorIds.isNone():
        for index, validator in getStateField(state, validators).pairs():
          let sres = validator.getStatus(current_epoch)
          if sres.isOk:
            let vstatus = sres.get()
            let includeFlag = statusCheck(status, squery, vstatus,
                                          current_epoch)
            if includeFlag:
              res.add((validator: validator,
                       index: uint64(index),
                       status: vstatus,
                       balance: getStateField(state, balances).asSeq()[index]))
      else:
        for index in vquery.ids:
          if index < lenu64(getStateField(state, validators)):
            let validator = getStateField(state, validators).asSeq()[index]
            let sres = validator.getStatus(current_epoch)
            if sres.isOk:
              let vstatus = sres.get()
              let includeFlag = statusCheck(status, squery, vstatus,
                                            current_epoch)
              if includeFlag:
                vquery.keyset.excl(validator.pubkey)
                res.add((validator: validator,
                         index: uint64(index),
                         status: vstatus,
                         balance: getStateField(state, balances).asSeq()[index]))

        for index, validator in getStateField(state, validators).pairs():
          if validator.pubkey in vquery.keyset:
            let sres = validator.getStatus(current_epoch)
            if sres.isOk:
              let vstatus = sres.get()
              let includeFlag = statusCheck(status, squery, vstatus,
                                            current_epoch)
              if includeFlag:
                res.add((validator: validator,
                         index: uint64(index),
                         status: vstatus,
                         balance: getStateField(state, balances).asSeq()[index]))
    return res

  rpcServer.rpc("get_v1_beacon_states_stateId_validators_validatorId") do (
      stateId: string, validatorId: string) -> RpcBeaconStatesValidators:
    let current_epoch = getStateField(node.dag.headState, slot).epoch
    let vqres = createIdQuery([validatorId])
    if vqres.isErr:
      raise newException(CatchableError, $vqres.error)
    let vquery = vqres.get()

    withStateForStateId(stateId):
      if len(vquery.ids) > 0:
        let index = vquery.ids[0]
        if index < lenu64(getStateField(state, validators)):
          let validator = getStateField(state, validators).asSeq()[index]
          let sres = validator.getStatus(current_epoch)
          if sres.isOk:
            return (validator: validator, index: uint64(index),
                    status: sres.get(),
                    balance: getStateField(state, balances).asSeq()[index])
          else:
            raise newException(CatchableError, "Incorrect validator's state")
      else:
        for index, validator in getStateField(state, validators).pairs():
          if validator.pubkey in vquery.keyset:
            let sres = validator.getStatus(current_epoch)
            if sres.isOk:
              return (validator: validator, index: uint64(index),
                      status: sres.get(),
                      balance: getStateField(state, balances).asSeq()[index])
            else:
              raise newException(CatchableError, "Incorrect validator's state")

  rpcServer.rpc("get_v1_beacon_states_stateId_validator_balances") do (
      stateId: string, validatorsId: Option[seq[string]]) -> seq[RpcBalance]:

    var res: seq[RpcBalance]
    withStateForStateId(stateId):
      if validatorsId.isNone():
        for index, value in getStateField(state, balances).pairs():
          let balance = (index: uint64(index), balance: value)
          res.add(balance)
      else:
        let vqres = createIdQuery(validatorsId.get())
        if vqres.isErr:
          raise newException(CatchableError, $vqres.error)

        var vquery = vqres.get()
        for index in vquery.ids:
          if index < lenu64(getStateField(state, validators)):
            let validator = getStateField(state, validators).asSeq()[index]
            vquery.keyset.excl(validator.pubkey)
            let balance = (index: uint64(index),
                           balance: getStateField(state, balances).asSeq()[index])
            res.add(balance)

        for index, validator in getStateField(state, validators).pairs():
          if validator.pubkey in vquery.keyset:
            let balance = (index: uint64(index),
                           balance: getStateField(state, balances).asSeq()[index])
            res.add(balance)
    return res

  rpcServer.rpc("get_v1_beacon_states_stateId_committees_epoch") do (
      stateId: string, epoch: Option[uint64], index: Option[uint64],
      slot: Option[uint64]) -> seq[RpcBeaconStatesCommittees]:
    withStateForStateId(stateId):
      proc getCommittee(slot: Slot,
                        index: CommitteeIndex): RpcBeaconStatesCommittees =
        let vals = get_beacon_committee(
          state, slot, index, cache).mapIt(it.uint64)
        return (index: index.uint64, slot: slot.uint64, validators: vals)

      proc forSlot(slot: Slot, res: var seq[RpcBeaconStatesCommittees]) =
        let committees_per_slot =
          get_committee_count_per_slot(state, slot.epoch, cache)

        if index.isNone:
          for committee_index in get_committee_indices(committees_per_slot):
            res.add(getCommittee(slot, committee_index))
        else:
          if index.get() < committees_per_slot:
            let cindex = CommitteeIndex.init(index.get()).expect(
              "valid because verified against committees_per_slot")
            res.add(getCommittee(slot, cindex))

      var res: seq[RpcBeaconStatesCommittees]

      let qepoch =
        if epoch.isNone:
          epoch(getStateField(state, slot))
        else:
          Epoch(epoch.get())

      if slot.isNone:
        for slot in qepoch.slots():
          forSlot(slot, res)
      else:
        forSlot(Slot(slot.get()), res)

      return res

  rpcServer.rpc("get_v1_beacon_headers") do (
      slot: Option[uint64], parent_root: Option[string]) ->
      seq[RpcBeaconHeaders]:
    unimplemented()

  rpcServer.rpc("get_v1_beacon_headers_blockId") do (
      blockId: string) ->
      tuple[canonical: bool, header: SignedBeaconBlockHeader]:
    let bd = node.getForkedBlockFromBlockId(blockId)
    return withBlck(bd):
      static: doAssert blck.signature is TrustedSig and
                sizeof(ValidatorSig) == sizeof(blck.signature)
      (
        canonical: node.dag.isCanonical(
          BlockId(root: blck.root, slot: blck.message.slot)),
        header: SignedBeaconBlockHeader(
          message: blck.toBeaconBlockHeader
        )
      )

  rpcServer.rpc("post_v1_beacon_blocks") do (blck: phase0.SignedBeaconBlock) -> int:
    let res = await sendBeaconBlock(node, ForkedSignedBeaconBlock.init(blck))
    if res.isErr():
      raise (ref CatchableError)(msg: $res.error())

    if res.get():
      # The block was validated successfully and has been broadcast.
      # It has also been integrated into the beacon node's database.
      return 200
    else:
      # The block failed validation, but was successfully broadcast anyway.
      # It was not integrated into the beacon node''s database.
      return 202

  rpcServer.rpc("get_v1_beacon_blocks_blockId") do (
      blockId: string) -> phase0.TrustedSignedBeaconBlock:
    let blck = node.getForkedBlockFromBlockId(blockId)
    if blck.kind == BeaconBlockFork.Phase0:
      return blck.phase0Data
    else:
      raiseNoAltairSupport()

  rpcServer.rpc("get_v1_beacon_blocks_blockId_root") do (
      blockId: string) -> Eth2Digest:
    return withBlck(node.getForkedBlockFromBlockId(blockId)):
      blck.root

  rpcServer.rpc("get_v1_beacon_blocks_blockId_attestations") do (
      blockId: string) -> seq[TrustedAttestation]:
    return withBlck(node.getForkedBlockFromBlockId(blockId)):
      blck.message.body.attestations.asSeq

  rpcServer.rpc("get_v1_beacon_pool_attestations") do (
      slot: Option[uint64], committee_index: Option[uint64]) ->
      seq[RpcAttestation]:

    var res: seq[RpcAttestation]

    let qslot =
      if slot.isSome():
        some(Slot(slot.get()))
      else:
        none[Slot]()

    let qindex =
      if committee_index.isSome():
        some(CommitteeIndex(committee_index.get()))
      else:
        none[CommitteeIndex]()

    for item in node.attestationPool[].attestations(qslot, qindex):
      let atuple = (
        aggregation_bits: to0xHex(item.aggregation_bits.bytes),
        data: item.data,
        signature: item.signature
      )
      res.add(atuple)

    return res

  rpcServer.rpc("post_v1_beacon_pool_attestations") do (
      attestation: Attestation) -> bool:
    let res = await node.sendAttestation(attestation)
    if not res.isOk():
      raise (ref CatchableError)(msg: $res.error())
    return true

  rpcServer.rpc("get_v1_beacon_pool_attester_slashings") do (
      ) -> seq[AttesterSlashing]:
    var res: seq[AttesterSlashing]
    if isNil(node.exitPool):
      return res
    let length = len(node.exitPool.attester_slashings)
    res = newSeqOfCap[AttesterSlashing](length)
    for item in node.exitPool.attester_slashings.items():
      res.add(item)
    return res

  rpcServer.rpc("post_v1_beacon_pool_attester_slashings") do (
      slashing: AttesterSlashing) -> bool:
    let res = node.sendAttesterSlashing(slashing)
    if not res.isOk():
      raise (ref CatchableError)(msg: $res.error())
    return true

  rpcServer.rpc("get_v1_beacon_pool_proposer_slashings") do (
      ) -> seq[ProposerSlashing]:
    var res: seq[ProposerSlashing]
    if isNil(node.exitPool):
      return res
    let length = len(node.exitPool.proposer_slashings)
    res = newSeqOfCap[ProposerSlashing](length)
    for item in node.exitPool.proposer_slashings.items():
      res.add(item)
    return res

  rpcServer.rpc("post_v1_beacon_pool_proposer_slashings") do (
      slashing: ProposerSlashing) -> bool:
    let res = node.sendProposerSlashing(slashing)
    if not res.isOk():
      raise (ref CatchableError)(msg: $res.error())
    return true

  rpcServer.rpc("get_v1_beacon_pool_voluntary_exits") do (
      ) -> seq[SignedVoluntaryExit]:
    var res: seq[SignedVoluntaryExit]
    if isNil(node.exitPool):
      return res
    let length = len(node.exitPool.voluntary_exits)
    res = newSeqOfCap[SignedVoluntaryExit](length)
    for item in node.exitPool.voluntary_exits.items():
      res.add(item)
    return res

  rpcServer.rpc("post_v1_beacon_pool_voluntary_exits") do (
      exit: SignedVoluntaryExit) -> bool:
    let res = node.sendVoluntaryExit(exit)
    if not res.isOk():
      raise (ref CatchableError)(msg: $res.error())
    return true