# 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/options,
  chronicles,
  json_rpc/servers/httpserver,
  eth/p2p/discoveryv5/enr,
  libp2p/[multiaddress, multicodec],
  nimcrypto/utils as ncrutils,
  ../beacon_node_common, ../version,
  ../networking/[eth2_network, peer_pool],
  ../sync/sync_manager,
  ../spec/datatypes/base,
  ./rpc_utils

logScope: topics = "nodeapi"

type
  RpcServer = RpcHttpServer

proc validateState(state: Option[seq[string]]): Option[set[ConnectionState]] =
  var res: set[ConnectionState]
  if state.isSome():
    let states = state.get()
    for item in states:
      case item
      of "disconnected":
        if ConnectionState.Disconnected notin res:
          res.incl(ConnectionState.Disconnected)
        else:
          # `state` values should be unique
          return none(set[ConnectionState])
      of "connecting":
        if ConnectionState.Disconnected notin res:
          res.incl(ConnectionState.Connecting)
        else:
          # `state` values should be unique
          return none(set[ConnectionState])
      of "connected":
        if ConnectionState.Connected notin res:
          res.incl(ConnectionState.Connected)
        else:
          # `state` values should be unique
          return none(set[ConnectionState])
      of "disconnecting":
        if ConnectionState.Disconnecting notin res:
          res.incl(ConnectionState.Disconnecting)
        else:
          # `state` values should be unique
          return none(set[ConnectionState])
      else:
        # Found incorrect `state` string value
        return none(set[ConnectionState])

  if res == {}:
    res = {ConnectionState.Connecting, ConnectionState.Connected,
           ConnectionState.Disconnecting, ConnectionState.Disconnected}
  some(res)

proc validateDirection(direction: Option[seq[string]]): Option[set[PeerType]] =
  var res: set[PeerType]
  if direction.isSome():
    let directions = direction.get()
    for item in directions:
      case item
      of "inbound":
        if PeerType.Incoming notin res:
          res.incl(PeerType.Incoming)
        else:
          # `direction` values should be unique
          return none(set[PeerType])
      of "outbound":
        if PeerType.Outgoing notin res:
          res.incl(PeerType.Outgoing)
        else:
          # `direction` values should be unique
          return none(set[PeerType])
      else:
        # Found incorrect `direction` string value
        return none(set[PeerType])

  if res == {}:
    res = {PeerType.Incoming, PeerType.Outgoing}
  some(res)

proc toString(state: ConnectionState): string =
  case state
  of ConnectionState.Disconnected:
    "disconnected"
  of ConnectionState.Connecting:
    "connecting"
  of ConnectionState.Connected:
    "connected"
  of ConnectionState.Disconnecting:
    "disconnecting"
  else:
    ""

proc toString(direction: PeerType): string =
  case direction:
  of PeerType.Incoming:
    "inbound"
  of PeerType.Outgoing:
    "outbound"

proc getLastSeenAddress(info: PeerInfo): string =
  # TODO (cheatfate): We need to provide filter here, which will be able to
  # filter such multiaddresses like `/ip4/0.0.0.0` or local addresses or
  # addresses with peer ids.
  if len(info.addrs) > 0:
    $info.addrs[len(info.addrs) - 1]
  else:
    ""

proc getDiscoveryAddresses(node: BeaconNode): Option[seq[string]] =
  let restr = node.network.enrRecord().toTypedRecord()
  if restr.isErr():
    return none[seq[string]]()
  let respa = restr.get().toPeerAddr(udpProtocol)
  if respa.isErr():
    return none[seq[string]]()
  let pa = respa.get()
  let mpa = MultiAddress.init(multicodec("p2p"), pa.peerId)
  if mpa.isErr():
    return none[seq[string]]()
  var addresses = newSeqOfCap[string](len(pa.addrs))
  for item in pa.addrs:
    let resa = concat(item, mpa.get())
    if resa.isOk():
      addresses.add($(resa.get()))
  return some(addresses)

proc getP2PAddresses(node: BeaconNode): Option[seq[string]] =
  let pinfo = node.network.switch.peerInfo
  let mpa = MultiAddress.init(multicodec("p2p"), pinfo.peerId)
  if mpa.isErr():
    return none[seq[string]]()
  var addresses = newSeqOfCap[string](len(pinfo.addrs))
  for item in pinfo.addrs:
    let resa = concat(item, mpa.get())
    if resa.isOk():
      addresses.add($(resa.get()))
  return some(addresses)

proc installNodeApiHandlers*(rpcServer: RpcServer, node: BeaconNode) {.
    raises: [Defect, CatchableError].} =
  rpcServer.rpc("get_v1_node_identity") do () -> RpcNodeIdentity:
    let discoveryAddresses =
      block:
        let res = node.getDiscoveryAddresses()
        if res.isSome():
          res.get()
        else:
          newSeq[string](0)

    let p2pAddresses =
      block:
        let res = node.getP2PAddresses()
        if res.isSome():
          res.get()
        else:
          newSeq[string]()

    return (
      peer_id: $node.network.peerId(),
      enr: node.network.enrRecord().toUri(),
      p2p_addresses: p2pAddresses,
      discovery_addresses: discoveryAddresses,
      metadata: (node.network.metadata.seq_number,
                 "0x" & ncrutils.toHex(node.network.metadata.attnets.bytes))
    )

  rpcServer.rpc("get_v1_node_peers") do (state: Option[seq[string]],
                          direction: Option[seq[string]]) -> seq[RpcNodePeer]:
    var res = newSeq[RpcNodePeer]()
    let rstates = validateState(state)
    if rstates.isNone():
      raise newException(CatchableError, "Incorrect state parameter")
    let rdirs = validateDirection(direction)
    if rdirs.isNone():
      raise newException(CatchableError, "Incorrect direction parameter")
    let states = rstates.get()
    let dirs = rdirs.get()
    for item in node.network.peers.values():
      if (item.connectionState in states) and (item.direction in dirs):
        let peer = (
          peer_id: $item.info.peerId,
          enr: if item.enr.isSome(): item.enr.get().toUri() else: "",
          last_seen_p2p_address: item.info.getLastSeenAddress(),
          state: item.connectionState.toString(),
          direction: item.direction.toString(),
          agent: item.info.agentVersion, # Fields `agent` and `proto` are not
          proto: item.info.protoVersion  # part of specification.
        )
        res.add(peer)
    return res

  rpcServer.rpc("get_v1_node_peer_count") do () -> RpcNodePeerCount:
    var res: RpcNodePeerCount
    for item in node.network.peers.values():
      case item.connectionState
      of ConnectionState.Connecting:
        inc(res.connecting)
      of ConnectionState.Connected:
        inc(res.connected)
      of ConnectionState.Disconnecting:
        inc(res.disconnecting)
      of ConnectionState.Disconnected:
        inc(res.disconnected)
      of ConnectionState.None:
        discard
    return res

  rpcServer.rpc("get_v1_node_peers_peerId") do (
    peer_id: string) -> RpcNodePeer:
    let pres = PeerID.init(peer_id)
    if pres.isErr():
      raise newException(CatchableError,
                         "The peer ID supplied could not be parsed")
    let pid = pres.get()
    let peer = node.network.peers.getOrDefault(pid)
    if isNil(peer):
      raise newException(CatchableError, "Peer not found")

    return (
      peer_id: $peer.info.peerId,
      enr: if peer.enr.isSome(): peer.enr.get().toUri() else: "",
      last_seen_p2p_address: peer.info.getLastSeenAddress(),
      state: peer.connectionState.toString(),
      direction: peer.direction.toString(),
      agent: peer.info.agentVersion, # Fields `agent` and `proto` are not part
      proto: peer.info.protoVersion  # of specification
    )

  rpcServer.rpc("get_v1_node_version") do () -> JsonNode:
    return %*{"version": "Nimbus/" & fullVersionStr}

  rpcServer.rpc("get_v1_node_syncing") do () -> RpcSyncInfo:
    return node.syncManager.getInfo()

  rpcServer.rpc("get_v1_node_health") do () -> JsonNode:
    # TODO: There currently no way to situation when we node has issues, so
    # its impossible to return HTTP ERROR 503 according to specification.
    if node.syncManager.inProgress:
      # We need to return HTTP ERROR 206 according to specification
      return %*{"health": 206}
    else:
      return %*{"health": 200}